@solana/web3.js 1.56.2 → 1.59.0

package/lib/index.iife.js

@@ -2417,6 +2417,7 @@ var solanaWeb3 = (function (exports) {
 	var assert$3 = assert$2;
 
 	/*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+	const u32$1 = (arr) => new Uint32Array(arr.buffer, arr.byteOffset, Math.floor(arr.byteLength / 4));
 	// Cast array to view
 	const createView = (arr) => new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
 	// The rotate right (circular right shift) operation for uint32
@@ -2455,6 +2456,14 @@ var solanaWeb3 = (function (exports) {
 	    hashC.create = () => hashConstructor();
 	    return hashC;
 	}
+	function wrapConstructorWithOpts(hashCons) {
+	    const hashC = (msg, opts) => hashCons(opts).update(toBytes(msg)).digest();
+	    const tmp = hashCons({});
+	    hashC.outputLen = tmp.outputLen;
+	    hashC.blockLen = tmp.blockLen;
+	    hashC.create = (opts) => hashCons(opts);
+	    return hashC;
+	}
 
 	// Polyfill for Safari 14
 	function setBigUint64(view, byteOffset, value, isLE) {
@@ -2832,22 +2841,22 @@ var solanaWeb3 = (function (exports) {
 	});
 
 	/*! noble-ed25519 - MIT License (c) 2019 Paul Miller (paulmillr.com) */
-	const _0n$1 = BigInt(0);
-	const _1n$1 = BigInt(1);
-	const _2n$1 = BigInt(2);
+	const _0n$2 = BigInt(0);
+	const _1n$2 = BigInt(1);
+	const _2n$2 = BigInt(2);
 	const _255n = BigInt(255);
-	const CURVE_ORDER = _2n$1 ** BigInt(252) + BigInt('27742317777372353535851937790883648493');
+	const CURVE_ORDER = _2n$2 ** BigInt(252) + BigInt('27742317777372353535851937790883648493');
 	const CURVE$1 = Object.freeze({
 	    a: BigInt(-1),
 	    d: BigInt('37095705934669439343138083508754565189542113879843219016388785533085940283555'),
-	    P: _2n$1 ** _255n - BigInt(19),
+	    P: _2n$2 ** _255n - BigInt(19),
 	    l: CURVE_ORDER,
 	    n: CURVE_ORDER,
 	    h: BigInt(8),
 	    Gx: BigInt('15112221349535400772501151409588531511454012693041857206046113283949847762202'),
 	    Gy: BigInt('46316835694926478169428394003475163141307993866256225615783033603165251855960'),
 	});
-	const MAX_256B = _2n$1 ** BigInt(256);
+	const MAX_256B = _2n$2 ** BigInt(256);
 	const SQRT_M1 = BigInt('19681161376707505956807079304988542015446066515923890162744021073123829784752');
 	BigInt('6853475219497561581579357271197624642482790079785650197046958215289687604742');
 	BigInt('25063068953384623474111414158702152701244531502492656460079210482610430750235');
@@ -2867,7 +2876,7 @@ var solanaWeb3 = (function (exports) {
 	        }
 	        if (p.equals(Point$1.ZERO))
 	            return ExtendedPoint.ZERO;
-	        return new ExtendedPoint(p.x, p.y, _1n$1, mod$1(p.x * p.y));
+	        return new ExtendedPoint(p.x, p.y, _1n$2, mod$1(p.x * p.y));
 	    }
 	    static toAffineBatch(points) {
 	        const toInv = invertBatch$1(points.map((p) => p.z));
@@ -2892,11 +2901,11 @@ var solanaWeb3 = (function (exports) {
 	    double() {
 	        const { x: X1, y: Y1, z: Z1 } = this;
 	        const { a } = CURVE$1;
-	        const A = mod$1(X1 ** _2n$1);
-	        const B = mod$1(Y1 ** _2n$1);
-	        const C = mod$1(_2n$1 * mod$1(Z1 ** _2n$1));
+	        const A = mod$1(X1 ** _2n$2);
+	        const B = mod$1(Y1 ** _2n$2);
+	        const C = mod$1(_2n$2 * mod$1(Z1 ** _2n$2));
 	        const D = mod$1(a * A);
-	        const E = mod$1(mod$1((X1 + Y1) ** _2n$1) - A - B);
+	        const E = mod$1(mod$1((X1 + Y1) ** _2n$2) - A - B);
 	        const G = D + B;
 	        const F = G - C;
 	        const H = D - B;
@@ -2913,10 +2922,10 @@ var solanaWeb3 = (function (exports) {
 	        const A = mod$1((Y1 - X1) * (Y2 + X2));
 	        const B = mod$1((Y1 + X1) * (Y2 - X2));
 	        const F = mod$1(B - A);
-	        if (F === _0n$1)
+	        if (F === _0n$2)
 	            return this.double();
-	        const C = mod$1(Z1 * _2n$1 * T2);
-	        const D = mod$1(T1 * _2n$1 * Z2);
+	        const C = mod$1(Z1 * _2n$2 * T2);
+	        const D = mod$1(T1 * _2n$2 * Z2);
 	        const E = D + C;
 	        const G = B + A;
 	        const H = D - C;
@@ -2973,7 +2982,7 @@ var solanaWeb3 = (function (exports) {
 	            n >>= shiftBy;
 	            if (wbits > windowSize) {
 	                wbits -= maxNumber;
-	                n += _1n$1;
+	                n += _1n$2;
 	            }
 	            if (wbits === 0) {
 	                let pr = precomputes[offset];
@@ -2997,19 +3006,19 @@ var solanaWeb3 = (function (exports) {
 	        let n = normalizeScalar$1(scalar, CURVE$1.l, false);
 	        const G = ExtendedPoint.BASE;
 	        const P0 = ExtendedPoint.ZERO;
-	        if (n === _0n$1)
+	        if (n === _0n$2)
 	            return P0;
-	        if (this.equals(P0) || n === _1n$1)
+	        if (this.equals(P0) || n === _1n$2)
 	            return this;
 	        if (this.equals(G))
 	            return this.wNAF(n);
 	        let p = P0;
 	        let d = this;
-	        while (n > _0n$1) {
-	            if (n & _1n$1)
+	        while (n > _0n$2) {
+	            if (n & _1n$2)
 	                p = p.add(d);
 	            d = d.double();
-	            n >>= _1n$1;
+	            n >>= _1n$2;
 	        }
 	        return p;
 	    }
@@ -3024,7 +3033,7 @@ var solanaWeb3 = (function (exports) {
 	        const ax = mod$1(x * invZ);
 	        const ay = mod$1(y * invZ);
 	        const zz = mod$1(z * invZ);
-	        if (zz !== _1n$1)
+	        if (zz !== _1n$2)
 	            throw new Error('invZ was invalid');
 	        return new Point$1(ax, ay);
 	    }
@@ -3038,8 +3047,8 @@ var solanaWeb3 = (function (exports) {
 	        legacyRist();
 	    }
 	}
-	ExtendedPoint.BASE = new ExtendedPoint(CURVE$1.Gx, CURVE$1.Gy, _1n$1, mod$1(CURVE$1.Gx * CURVE$1.Gy));
-	ExtendedPoint.ZERO = new ExtendedPoint(_0n$1, _1n$1, _1n$1, _0n$1);
+	ExtendedPoint.BASE = new ExtendedPoint(CURVE$1.Gx, CURVE$1.Gy, _1n$2, mod$1(CURVE$1.Gx * CURVE$1.Gy));
+	ExtendedPoint.ZERO = new ExtendedPoint(_0n$2, _1n$2, _1n$2, _0n$2);
 	function assertExtPoint(other) {
 	    if (!(other instanceof ExtendedPoint))
 	        throw new TypeError('ExtendedPoint expected');
@@ -3068,12 +3077,12 @@ var solanaWeb3 = (function (exports) {
 	        if (!strict && y >= MAX_256B)
 	            throw new Error('Expected 0 < hex < 2**256');
 	        const y2 = mod$1(y * y);
-	        const u = mod$1(y2 - _1n$1);
-	        const v = mod$1(d * y2 + _1n$1);
+	        const u = mod$1(y2 - _1n$2);
+	        const v = mod$1(d * y2 + _1n$2);
 	        let { isValid, value: x } = uvRatio(u, v);
 	        if (!isValid)
 	            throw new Error('Point.fromHex: invalid y coordinate');
-	        const isXOdd = (x & _1n$1) === _1n$1;
+	        const isXOdd = (x & _1n$2) === _1n$2;
 	        const isLastByteOdd = (hex[31] & 0x80) !== 0;
 	        if (isLastByteOdd !== isXOdd) {
 	            x = mod$1(-x);
@@ -3085,7 +3094,7 @@ var solanaWeb3 = (function (exports) {
 	    }
 	    toRawBytes() {
 	        const bytes = numberTo32BytesLE(this.y);
-	        bytes[31] |= this.x & _1n$1 ? 0x80 : 0;
+	        bytes[31] |= this.x & _1n$2 ? 0x80 : 0;
 	        return bytes;
 	    }
 	    toHex() {
@@ -3093,7 +3102,7 @@ var solanaWeb3 = (function (exports) {
 	    }
 	    toX25519() {
 	        const { y } = this;
-	        const u = mod$1((_1n$1 + y) * invert$1(_1n$1 - y));
+	        const u = mod$1((_1n$2 + y) * invert$1(_1n$2 - y));
 	        return numberTo32BytesLE(u);
 	    }
 	    isTorsionFree() {
@@ -3116,7 +3125,7 @@ var solanaWeb3 = (function (exports) {
 	    }
 	}
 	Point$1.BASE = new Point$1(CURVE$1.Gx, CURVE$1.Gy);
-	Point$1.ZERO = new Point$1(_0n$1, _1n$1);
+	Point$1.ZERO = new Point$1(_0n$2, _1n$2);
 	class Signature$1 {
 	    constructor(r, s) {
 	        this.r = r;
@@ -3196,7 +3205,7 @@ var solanaWeb3 = (function (exports) {
 	    return numberTo32BytesBE(num).reverse();
 	}
 	function edIsNegative(num) {
-	    return (mod$1(num) & _1n$1) === _1n$1;
+	    return (mod$1(num) & _1n$2) === _1n$2;
 	}
 	function bytesToNumberLE(uint8a) {
 	    if (!(uint8a instanceof Uint8Array))
@@ -3205,37 +3214,37 @@ var solanaWeb3 = (function (exports) {
 	}
 	function mod$1(a, b = CURVE$1.P) {
 	    const res = a % b;
-	    return res >= _0n$1 ? res : b + res;
+	    return res >= _0n$2 ? res : b + res;
 	}
 	function invert$1(number, modulo = CURVE$1.P) {
-	    if (number === _0n$1 || modulo <= _0n$1) {
+	    if (number === _0n$2 || modulo <= _0n$2) {
 	        throw new Error(`invert: expected positive integers, got n=${number} mod=${modulo}`);
 	    }
 	    let a = mod$1(number, modulo);
 	    let b = modulo;
-	    let x = _0n$1, u = _1n$1;
-	    while (a !== _0n$1) {
+	    let x = _0n$2, u = _1n$2;
+	    while (a !== _0n$2) {
 	        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$1)
+	    if (gcd !== _1n$2)
 	        throw new Error('invert: does not exist');
 	    return mod$1(x, modulo);
 	}
 	function invertBatch$1(nums, p = CURVE$1.P) {
 	    const tmp = new Array(nums.length);
 	    const lastMultiplied = nums.reduce((acc, num, i) => {
-	        if (num === _0n$1)
+	        if (num === _0n$2)
 	            return acc;
 	        tmp[i] = acc;
 	        return mod$1(acc * num, p);
-	    }, _1n$1);
+	    }, _1n$2);
 	    const inverted = invert$1(lastMultiplied, p);
 	    nums.reduceRight((acc, num, i) => {
-	        if (num === _0n$1)
+	        if (num === _0n$2)
 	            return acc;
 	        tmp[i] = mod$1(acc * tmp[i], p);
 	        return mod$1(acc * num, p);
@@ -3245,7 +3254,7 @@ var solanaWeb3 = (function (exports) {
 	function pow2$1(x, power) {
 	    const { P } = CURVE$1;
 	    let res = x;
-	    while (power-- > _0n$1) {
+	    while (power-- > _0n$2) {
 	        res *= res;
 	        res %= P;
 	    }
@@ -3260,8 +3269,8 @@ var solanaWeb3 = (function (exports) {
 	    const _80n = BigInt(80);
 	    const x2 = (x * x) % P;
 	    const b2 = (x2 * x) % P;
-	    const b4 = (pow2$1(b2, _2n$1) * b2) % P;
-	    const b5 = (pow2$1(b4, _1n$1) * x) % P;
+	    const b4 = (pow2$1(b2, _2n$2) * b2) % P;
+	    const b5 = (pow2$1(b4, _1n$2) * x) % P;
 	    const b10 = (pow2$1(b5, _5n) * b5) % P;
 	    const b20 = (pow2$1(b10, _10n) * b10) % P;
 	    const b40 = (pow2$1(b20, _20n) * b20) % P;
@@ -3269,7 +3278,7 @@ var solanaWeb3 = (function (exports) {
 	    const b160 = (pow2$1(b80, _80n) * b80) % P;
 	    const b240 = (pow2$1(b160, _80n) * b80) % P;
 	    const b250 = (pow2$1(b240, _10n) * b10) % P;
-	    const pow_p_5_8 = (pow2$1(b250, _2n$1) * x) % P;
+	    const pow_p_5_8 = (pow2$1(b250, _2n$2) * x) % P;
 	    return { pow_p_5_8, b2 };
 	}
 	function uvRatio(u, v) {
@@ -3307,11 +3316,11 @@ var solanaWeb3 = (function (exports) {
 	        num = BigInt(num);
 	    if (typeof num === 'bigint' && num < max) {
 	        if (strict) {
-	            if (_0n$1 < num)
+	            if (_0n$2 < num)
 	                return num;
 	        }
 	        else {
-	            if (_0n$1 <= num)
+	            if (_0n$2 <= num)
 	                return num;
 	        }
 	    }
@@ -3415,7 +3424,7 @@ var solanaWeb3 = (function (exports) {
 	        hash = ensureBytes$1(hash);
 	        if (hash.length < 40 || hash.length > 1024)
 	            throw new Error('Expected 40-1024 bytes of private key as per FIPS 186');
-	        return mod$1(bytesToNumberLE(hash), CURVE$1.l - _1n$1) + _1n$1;
+	        return mod$1(bytesToNumberLE(hash), CURVE$1.l - _1n$2) + _1n$2;
 	    },
 	    randomBytes: (bytesLength = 32) => {
 	        if (crypto$2.web) {
@@ -3448,7 +3457,7 @@ var solanaWeb3 = (function (exports) {
 	    precompute(windowSize = 8, point = Point$1.BASE) {
 	        const cached = point.equals(Point$1.BASE) ? point : new Point$1(point.x, point.y);
 	        cached._setWindowSize(windowSize);
-	        cached.multiply(_2n$1);
+	        cached.multiply(_2n$2);
 	        return cached;
 	    },
 	    sha512Sync: undefined,
@@ -8308,12 +8317,14 @@ var solanaWeb3 = (function (exports) {
 
 	function isPublicKeyData(value) {
 	  return value._bn !== undefined;
-	}
+	} // local counter used by PublicKey.unique()
+
+
+	let uniquePublicKeyCounter = 1;
 	/**
 	 * A public key
 	 */
 
-
 	class PublicKey extends Struct$1 {
 	  /** @internal */
 
@@ -8346,6 +8357,16 @@ var solanaWeb3 = (function (exports) {
 	      }
 	    }
 	  }
+	  /**
+	   * Returns a unique PublicKey for tests and benchmarks using acounter
+	   */
+
+
+	  static unique() {
+	    const key = new PublicKey(uniquePublicKeyCounter);
+	    uniquePublicKeyCounter += 1;
+	    return new PublicKey(key.toBuffer());
+	  }
 	  /**
 	   * Default public key value. (All zeros)
 	   */
@@ -10885,10 +10906,74 @@ var solanaWeb3 = (function (exports) {
 	  value: 'TransactionExpiredTimeoutError'
 	});
 
+	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 blob(32, property);
 	};
@@ -10952,6 +11037,13 @@ var solanaWeb3 = (function (exports) {
 	const voteInit = (property = 'voteInit') => {
 	  return struct([publicKey('nodePubkey'), publicKey('authorizedVoter'), publicKey('authorizedWithdrawer'), u8('commission')], property);
 	};
+	/**
+	 *  Layout for a VoteAuthorizeWithSeedArgs object
+	 */
+
+	const voteAuthorizeWithSeedArgs = (property = 'voteAuthorizeWithSeedArgs') => {
+	  return struct([u32('voteAuthorizationType'), publicKey('currentAuthorityDerivedKeyOwnerPubkey'), rustString('currentAuthorityDerivedKeySeed'), publicKey('newAuthorized')], property);
+	};
 	function getAlloc(type, fields) {
 	  const getItemAlloc = item => {
 	    if (item.span >= 0) {
@@ -10964,6 +11056,11 @@ var solanaWeb3 = (function (exports) {
 	      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
 
 
@@ -11010,6 +11107,129 @@ var solanaWeb3 = (function (exports) {
 	  }
 	}
 
+	function assert$1 (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$1(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$1(writableSigners.length > 0, 'Expected at least one writable signer key');
+	      const [payerAddress] = writableSigners[0];
+	      assert$1(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$1(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
 	 */
@@ -11047,6 +11267,27 @@ var solanaWeb3 = (function (exports) {
 	    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$1.encode(ix.data)
+	    }));
+	    return new Message({
+	      header,
+	      accountKeys: staticAccountKeys,
+	      recentBlockhash: args.recentBlockhash,
+	      instructions
+	    });
+	  }
+
 	  isAccountSigner(index) {
 	    return index < this.header.numRequiredSignatures;
 	  }
@@ -11136,7 +11377,7 @@ var solanaWeb3 = (function (exports) {
 	    for (let i = 0; i < accountCount; i++) {
 	      const account = byteArray.slice(0, PUBLIC_KEY_LENGTH);
 	      byteArray = byteArray.slice(PUBLIC_KEY_LENGTH);
-	      accountKeys.push(bs58$1.encode(buffer.Buffer.from(account)));
+	      accountKeys.push(new PublicKey(buffer.Buffer.from(account)));
 	    }
 
 	    const recentBlockhash = byteArray.slice(0, PUBLIC_KEY_LENGTH);
@@ -11175,12 +11416,6 @@ var solanaWeb3 = (function (exports) {
 
 	}
 
-	function assert$1 (condition, message) {
-	  if (!condition) {
-	    throw new Error(message || 'Assertion failed');
-	  }
-	}
-
 	/**
 	 * Message constructor arguments
 	 */
@@ -11203,6 +11438,102 @@ var solanaWeb3 = (function (exports) {
 	    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) {
+	      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) {
+	      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);
+	  }
+
+	  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);
@@ -12097,6 +12428,114 @@ var solanaWeb3 = (function (exports) {
 
 	}
 
+	class TransactionMessage {
+	  constructor(args) {
+	    this.accountKeys = void 0;
+	    this.instructions = void 0;
+	    this.recentBlockhash = void 0;
+	    this.accountKeys = args.accountKeys;
+	    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$1(numWritableSignedAccounts > 0, 'Message header is invalid');
+	    const numWritableUnsignedAccounts = message.staticAccountKeys.length - numReadonlyUnsignedAccounts;
+	    assert$1(numWritableUnsignedAccounts >= 0, 'Message header is invalid');
+	    const accountKeys = message.getAccountKeys(args);
+	    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({
+	      accountKeys,
+	      instructions,
+	      recentBlockhash
+	    });
+	  }
+
+	  compileToLegacyMessage() {
+	    const payerKey = this.accountKeys.get(0);
+
+	    if (payerKey === undefined) {
+	      throw new Error('Failed to compile message because no account keys were found');
+	    }
+
+	    return Message.compile({
+	      payerKey,
+	      recentBlockhash: this.recentBlockhash,
+	      instructions: this.instructions
+	    });
+	  }
+
+	  compileToV0Message(addressLookupTableAccounts) {
+	    const payerKey = this.accountKeys.get(0);
+
+	    if (payerKey === undefined) {
+	      throw new Error('Failed to compile message because no account keys were found');
+	    }
+
+	    return MessageV0.compile({
+	      payerKey,
+	      recentBlockhash: this.recentBlockhash,
+	      instructions: this.instructions,
+	      addressLookupTableAccounts
+	    });
+	  }
+
+	}
+
 	/**
 	 * Versioned transaction class
 	 */
@@ -19563,12 +20002,46 @@ var solanaWeb3 = (function (exports) {
 
 	    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 = 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) {
@@ -19584,6 +20057,12 @@ var solanaWeb3 = (function (exports) {
 	      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 {
@@ -19666,10 +20145,32 @@ var solanaWeb3 = (function (exports) {
 	  }
 	  /**
 	   * Sign and send a transaction
+	   *
+	   * @deprecated Instead, call {@link sendTransaction} with a {@link
+	   * VersionedTransaction}
 	   */
 
 
-	  async sendTransaction(transaction, signers, options) {
+	  /**
+	   * Sign and send a transaction
+	   */
+	  // eslint-disable-next-line no-dupe-class-members
+	  async sendTransaction(transaction, signersOrOptions, options) {
+	    if ('message' 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;
+
 	    if (transaction.nonceInfo) {
 	      transaction.sign(...signers);
 	    } else {
@@ -21154,662 +21655,208 @@ var solanaWeb3 = (function (exports) {
 	}
 	Ed25519Program.programId = new PublicKey('Ed25519SigVerify111111111111111111111111111');
 
-	var sha3$1 = {exports: {}};
-
+	// Various per round constants calculations
+	const [SHA3_PI, SHA3_ROTL, _SHA3_IOTA] = [[], [], []];
+	const _0n$1 = BigInt(0);
+	const _1n$1 = BigInt(1);
+	const _2n$1 = BigInt(2);
+	const _7n = BigInt(7);
+	const _256n = BigInt(256);
+	const _0x71n = BigInt(0x71);
+	for (let round = 0, R = _1n$1, x = 1, y = 0; round < 24; round++) {
+	    // Pi
+	    [x, y] = [y, (2 * x + 3 * y) % 5];
+	    SHA3_PI.push(2 * (5 * y + x));
+	    // Rotational
+	    SHA3_ROTL.push((((round + 1) * (round + 2)) / 2) % 64);
+	    // Iota
+	    let t = _0n$1;
+	    for (let j = 0; j < 7; j++) {
+	        R = ((R << _1n$1) ^ ((R >> _7n) * _0x71n)) % _256n;
+	        if (R & _2n$1)
+	            t ^= _1n$1 << ((_1n$1 << BigInt(j)) - _1n$1);
+	    }
+	    _SHA3_IOTA.push(t);
+	}
+	const [SHA3_IOTA_H, SHA3_IOTA_L] = u64$2.split(_SHA3_IOTA, true);
+	// Left rotation (without 0, 32, 64)
+	const rotlH = (h, l, s) => s > 32 ? u64$2.rotlBH(h, l, s) : u64$2.rotlSH(h, l, s);
+	const rotlL = (h, l, s) => s > 32 ? u64$2.rotlBL(h, l, s) : u64$2.rotlSL(h, l, s);
+	// Same as keccakf1600, but allows to skip some rounds
+	function keccakP(s, rounds = 24) {
+	    const B = new Uint32Array(5 * 2);
+	    // NOTE: all indices are x2 since we store state as u32 instead of u64 (bigints to slow in js)
+	    for (let round = 24 - rounds; round < 24; round++) {
+	        // Theta θ
+	        for (let x = 0; x < 10; x++)
+	            B[x] = s[x] ^ s[x + 10] ^ s[x + 20] ^ s[x + 30] ^ s[x + 40];
+	        for (let x = 0; x < 10; x += 2) {
+	            const idx1 = (x + 8) % 10;
+	            const idx0 = (x + 2) % 10;
+	            const B0 = B[idx0];
+	            const B1 = B[idx0 + 1];
+	            const Th = rotlH(B0, B1, 1) ^ B[idx1];
+	            const Tl = rotlL(B0, B1, 1) ^ B[idx1 + 1];
+	            for (let y = 0; y < 50; y += 10) {
+	                s[x + y] ^= Th;
+	                s[x + y + 1] ^= Tl;
+	            }
+	        }
+	        // Rho (ρ) and Pi (π)
+	        let curH = s[2];
+	        let curL = s[3];
+	        for (let t = 0; t < 24; t++) {
+	            const shift = SHA3_ROTL[t];
+	            const Th = rotlH(curH, curL, shift);
+	            const Tl = rotlL(curH, curL, shift);
+	            const PI = SHA3_PI[t];
+	            curH = s[PI];
+	            curL = s[PI + 1];
+	            s[PI] = Th;
+	            s[PI + 1] = Tl;
+	        }
+	        // Chi (χ)
+	        for (let y = 0; y < 50; y += 10) {
+	            for (let x = 0; x < 10; x++)
+	                B[x] = s[y + x];
+	            for (let x = 0; x < 10; x++)
+	                s[y + x] ^= ~B[(x + 2) % 10] & B[(x + 4) % 10];
+	        }
+	        // Iota (ι)
+	        s[0] ^= SHA3_IOTA_H[round];
+	        s[1] ^= SHA3_IOTA_L[round];
+	    }
+	    B.fill(0);
+	}
+	class Keccak extends Hash {
+	    // NOTE: we accept arguments in bytes instead of bits here.
+	    constructor(blockLen, suffix, outputLen, enableXOF = false, rounds = 24) {
+	        super();
+	        this.blockLen = blockLen;
+	        this.suffix = suffix;
+	        this.outputLen = outputLen;
+	        this.enableXOF = enableXOF;
+	        this.rounds = rounds;
+	        this.pos = 0;
+	        this.posOut = 0;
+	        this.finished = false;
+	        this.destroyed = false;
+	        // Can be passed from user as dkLen
+	        assert$3.number(outputLen);
+	        // 1600 = 5x5 matrix of 64bit.  1600 bits === 200 bytes
+	        if (0 >= this.blockLen || this.blockLen >= 200)
+	            throw new Error('Sha3 supports only keccak-f1600 function');
+	        this.state = new Uint8Array(200);
+	        this.state32 = u32$1(this.state);
+	    }
+	    keccak() {
+	        keccakP(this.state32, this.rounds);
+	        this.posOut = 0;
+	        this.pos = 0;
+	    }
+	    update(data) {
+	        assert$3.exists(this);
+	        const { blockLen, state } = this;
+	        data = toBytes(data);
+	        const len = data.length;
+	        for (let pos = 0; pos < len;) {
+	            const take = Math.min(blockLen - this.pos, len - pos);
+	            for (let i = 0; i < take; i++)
+	                state[this.pos++] ^= data[pos++];
+	            if (this.pos === blockLen)
+	                this.keccak();
+	        }
+	        return this;
+	    }
+	    finish() {
+	        if (this.finished)
+	            return;
+	        this.finished = true;
+	        const { state, suffix, pos, blockLen } = this;
+	        // Do the padding
+	        state[pos] ^= suffix;
+	        if ((suffix & 0x80) !== 0 && pos === blockLen - 1)
+	            this.keccak();
+	        state[blockLen - 1] ^= 0x80;
+	        this.keccak();
+	    }
+	    writeInto(out) {
+	        assert$3.exists(this, false);
+	        assert$3.bytes(out);
+	        this.finish();
+	        const bufferOut = this.state;
+	        const { blockLen } = this;
+	        for (let pos = 0, len = out.length; pos < len;) {
+	            if (this.posOut >= blockLen)
+	                this.keccak();
+	            const take = Math.min(blockLen - this.posOut, len - pos);
+	            out.set(bufferOut.subarray(this.posOut, this.posOut + take), pos);
+	            this.posOut += take;
+	            pos += take;
+	        }
+	        return out;
+	    }
+	    xofInto(out) {
+	        // Sha3/Keccak usage with XOF is probably mistake, only SHAKE instances can do XOF
+	        if (!this.enableXOF)
+	            throw new Error('XOF is not possible for this instance');
+	        return this.writeInto(out);
+	    }
+	    xof(bytes) {
+	        assert$3.number(bytes);
+	        return this.xofInto(new Uint8Array(bytes));
+	    }
+	    digestInto(out) {
+	        assert$3.output(out, this);
+	        if (this.finished)
+	            throw new Error('digest() was already called');
+	        this.writeInto(out);
+	        this.destroy();
+	        return out;
+	    }
+	    digest() {
+	        return this.digestInto(new Uint8Array(this.outputLen));
+	    }
+	    destroy() {
+	        this.destroyed = true;
+	        this.state.fill(0);
+	    }
+	    _cloneInto(to) {
+	        const { blockLen, suffix, outputLen, rounds, enableXOF } = this;
+	        to || (to = new Keccak(blockLen, suffix, outputLen, enableXOF, rounds));
+	        to.state32.set(this.state32);
+	        to.pos = this.pos;
+	        to.posOut = this.posOut;
+	        to.finished = this.finished;
+	        to.rounds = rounds;
+	        // Suffix can change in cSHAKE
+	        to.suffix = suffix;
+	        to.outputLen = outputLen;
+	        to.enableXOF = enableXOF;
+	        to.destroyed = this.destroyed;
+	        return to;
+	    }
+	}
+	const gen = (suffix, blockLen, outputLen) => wrapConstructor(() => new Keccak(blockLen, suffix, outputLen));
+	gen(0x06, 144, 224 / 8);
 	/**
-	 * [js-sha3]{@link https://github.com/emn178/js-sha3}
-	 *
-	 * @version 0.8.0
-	 * @author Chen, Yi-Cyuan [emn178@gmail.com]
-	 * @copyright Chen, Yi-Cyuan 2015-2018
-	 * @license MIT
+	 * SHA3-256 hash function
+	 * @param message - that would be hashed
 	 */
-
-	(function (module) {
-		/*jslint bitwise: true */
-		(function () {
-
-		  var INPUT_ERROR = 'input is invalid type';
-		  var FINALIZE_ERROR = 'finalize already called';
-		  var WINDOW = typeof window === 'object';
-		  var root = WINDOW ? window : {};
-		  if (root.JS_SHA3_NO_WINDOW) {
-		    WINDOW = false;
-		  }
-		  var WEB_WORKER = !WINDOW && typeof self === 'object';
-		  var NODE_JS = !root.JS_SHA3_NO_NODE_JS && typeof process === 'object' && process.versions && process.versions.node;
-		  if (NODE_JS) {
-		    root = commonjsGlobal;
-		  } else if (WEB_WORKER) {
-		    root = self;
-		  }
-		  var COMMON_JS = !root.JS_SHA3_NO_COMMON_JS && 'object' === 'object' && module.exports;
-		  var ARRAY_BUFFER = !root.JS_SHA3_NO_ARRAY_BUFFER && typeof ArrayBuffer !== 'undefined';
-		  var HEX_CHARS = '0123456789abcdef'.split('');
-		  var SHAKE_PADDING = [31, 7936, 2031616, 520093696];
-		  var CSHAKE_PADDING = [4, 1024, 262144, 67108864];
-		  var KECCAK_PADDING = [1, 256, 65536, 16777216];
-		  var PADDING = [6, 1536, 393216, 100663296];
-		  var SHIFT = [0, 8, 16, 24];
-		  var RC = [1, 0, 32898, 0, 32906, 2147483648, 2147516416, 2147483648, 32907, 0, 2147483649,
-		    0, 2147516545, 2147483648, 32777, 2147483648, 138, 0, 136, 0, 2147516425, 0,
-		    2147483658, 0, 2147516555, 0, 139, 2147483648, 32905, 2147483648, 32771,
-		    2147483648, 32770, 2147483648, 128, 2147483648, 32778, 0, 2147483658, 2147483648,
-		    2147516545, 2147483648, 32896, 2147483648, 2147483649, 0, 2147516424, 2147483648];
-		  var BITS = [224, 256, 384, 512];
-		  var SHAKE_BITS = [128, 256];
-		  var OUTPUT_TYPES = ['hex', 'buffer', 'arrayBuffer', 'array', 'digest'];
-		  var CSHAKE_BYTEPAD = {
-		    '128': 168,
-		    '256': 136
-		  };
-
-		  if (root.JS_SHA3_NO_NODE_JS || !Array.isArray) {
-		    Array.isArray = function (obj) {
-		      return Object.prototype.toString.call(obj) === '[object Array]';
-		    };
-		  }
-
-		  if (ARRAY_BUFFER && (root.JS_SHA3_NO_ARRAY_BUFFER_IS_VIEW || !ArrayBuffer.isView)) {
-		    ArrayBuffer.isView = function (obj) {
-		      return typeof obj === 'object' && obj.buffer && obj.buffer.constructor === ArrayBuffer;
-		    };
-		  }
-
-		  var createOutputMethod = function (bits, padding, outputType) {
-		    return function (message) {
-		      return new Keccak(bits, padding, bits).update(message)[outputType]();
-		    };
-		  };
-
-		  var createShakeOutputMethod = function (bits, padding, outputType) {
-		    return function (message, outputBits) {
-		      return new Keccak(bits, padding, outputBits).update(message)[outputType]();
-		    };
-		  };
-
-		  var createCshakeOutputMethod = function (bits, padding, outputType) {
-		    return function (message, outputBits, n, s) {
-		      return methods['cshake' + bits].update(message, outputBits, n, s)[outputType]();
-		    };
-		  };
-
-		  var createKmacOutputMethod = function (bits, padding, outputType) {
-		    return function (key, message, outputBits, s) {
-		      return methods['kmac' + bits].update(key, message, outputBits, s)[outputType]();
-		    };
-		  };
-
-		  var createOutputMethods = function (method, createMethod, bits, padding) {
-		    for (var i = 0; i < OUTPUT_TYPES.length; ++i) {
-		      var type = OUTPUT_TYPES[i];
-		      method[type] = createMethod(bits, padding, type);
-		    }
-		    return method;
-		  };
-
-		  var createMethod = function (bits, padding) {
-		    var method = createOutputMethod(bits, padding, 'hex');
-		    method.create = function () {
-		      return new Keccak(bits, padding, bits);
-		    };
-		    method.update = function (message) {
-		      return method.create().update(message);
-		    };
-		    return createOutputMethods(method, createOutputMethod, bits, padding);
-		  };
-
-		  var createShakeMethod = function (bits, padding) {
-		    var method = createShakeOutputMethod(bits, padding, 'hex');
-		    method.create = function (outputBits) {
-		      return new Keccak(bits, padding, outputBits);
-		    };
-		    method.update = function (message, outputBits) {
-		      return method.create(outputBits).update(message);
-		    };
-		    return createOutputMethods(method, createShakeOutputMethod, bits, padding);
-		  };
-
-		  var createCshakeMethod = function (bits, padding) {
-		    var w = CSHAKE_BYTEPAD[bits];
-		    var method = createCshakeOutputMethod(bits, padding, 'hex');
-		    method.create = function (outputBits, n, s) {
-		      if (!n && !s) {
-		        return methods['shake' + bits].create(outputBits);
-		      } else {
-		        return new Keccak(bits, padding, outputBits).bytepad([n, s], w);
-		      }
-		    };
-		    method.update = function (message, outputBits, n, s) {
-		      return method.create(outputBits, n, s).update(message);
-		    };
-		    return createOutputMethods(method, createCshakeOutputMethod, bits, padding);
-		  };
-
-		  var createKmacMethod = function (bits, padding) {
-		    var w = CSHAKE_BYTEPAD[bits];
-		    var method = createKmacOutputMethod(bits, padding, 'hex');
-		    method.create = function (key, outputBits, s) {
-		      return new Kmac(bits, padding, outputBits).bytepad(['KMAC', s], w).bytepad([key], w);
-		    };
-		    method.update = function (key, message, outputBits, s) {
-		      return method.create(key, outputBits, s).update(message);
-		    };
-		    return createOutputMethods(method, createKmacOutputMethod, bits, padding);
-		  };
-
-		  var algorithms = [
-		    { name: 'keccak', padding: KECCAK_PADDING, bits: BITS, createMethod: createMethod },
-		    { name: 'sha3', padding: PADDING, bits: BITS, createMethod: createMethod },
-		    { name: 'shake', padding: SHAKE_PADDING, bits: SHAKE_BITS, createMethod: createShakeMethod },
-		    { name: 'cshake', padding: CSHAKE_PADDING, bits: SHAKE_BITS, createMethod: createCshakeMethod },
-		    { name: 'kmac', padding: CSHAKE_PADDING, bits: SHAKE_BITS, createMethod: createKmacMethod }
-		  ];
-
-		  var methods = {}, methodNames = [];
-
-		  for (var i = 0; i < algorithms.length; ++i) {
-		    var algorithm = algorithms[i];
-		    var bits = algorithm.bits;
-		    for (var j = 0; j < bits.length; ++j) {
-		      var methodName = algorithm.name + '_' + bits[j];
-		      methodNames.push(methodName);
-		      methods[methodName] = algorithm.createMethod(bits[j], algorithm.padding);
-		      if (algorithm.name !== 'sha3') {
-		        var newMethodName = algorithm.name + bits[j];
-		        methodNames.push(newMethodName);
-		        methods[newMethodName] = methods[methodName];
-		      }
-		    }
-		  }
-
-		  function Keccak(bits, padding, outputBits) {
-		    this.blocks = [];
-		    this.s = [];
-		    this.padding = padding;
-		    this.outputBits = outputBits;
-		    this.reset = true;
-		    this.finalized = false;
-		    this.block = 0;
-		    this.start = 0;
-		    this.blockCount = (1600 - (bits << 1)) >> 5;
-		    this.byteCount = this.blockCount << 2;
-		    this.outputBlocks = outputBits >> 5;
-		    this.extraBytes = (outputBits & 31) >> 3;
-
-		    for (var i = 0; i < 50; ++i) {
-		      this.s[i] = 0;
-		    }
-		  }
-
-		  Keccak.prototype.update = function (message) {
-		    if (this.finalized) {
-		      throw new Error(FINALIZE_ERROR);
-		    }
-		    var notString, type = typeof message;
-		    if (type !== 'string') {
-		      if (type === 'object') {
-		        if (message === null) {
-		          throw new Error(INPUT_ERROR);
-		        } else if (ARRAY_BUFFER && message.constructor === ArrayBuffer) {
-		          message = new Uint8Array(message);
-		        } else if (!Array.isArray(message)) {
-		          if (!ARRAY_BUFFER || !ArrayBuffer.isView(message)) {
-		            throw new Error(INPUT_ERROR);
-		          }
-		        }
-		      } else {
-		        throw new Error(INPUT_ERROR);
-		      }
-		      notString = true;
-		    }
-		    var blocks = this.blocks, byteCount = this.byteCount, length = message.length,
-		      blockCount = this.blockCount, index = 0, s = this.s, i, code;
-
-		    while (index < length) {
-		      if (this.reset) {
-		        this.reset = false;
-		        blocks[0] = this.block;
-		        for (i = 1; i < blockCount + 1; ++i) {
-		          blocks[i] = 0;
-		        }
-		      }
-		      if (notString) {
-		        for (i = this.start; index < length && i < byteCount; ++index) {
-		          blocks[i >> 2] |= message[index] << SHIFT[i++ & 3];
-		        }
-		      } else {
-		        for (i = this.start; index < length && i < byteCount; ++index) {
-		          code = message.charCodeAt(index);
-		          if (code < 0x80) {
-		            blocks[i >> 2] |= code << SHIFT[i++ & 3];
-		          } else if (code < 0x800) {
-		            blocks[i >> 2] |= (0xc0 | (code >> 6)) << SHIFT[i++ & 3];
-		            blocks[i >> 2] |= (0x80 | (code & 0x3f)) << SHIFT[i++ & 3];
-		          } else if (code < 0xd800 || code >= 0xe000) {
-		            blocks[i >> 2] |= (0xe0 | (code >> 12)) << SHIFT[i++ & 3];
-		            blocks[i >> 2] |= (0x80 | ((code >> 6) & 0x3f)) << SHIFT[i++ & 3];
-		            blocks[i >> 2] |= (0x80 | (code & 0x3f)) << SHIFT[i++ & 3];
-		          } else {
-		            code = 0x10000 + (((code & 0x3ff) << 10) | (message.charCodeAt(++index) & 0x3ff));
-		            blocks[i >> 2] |= (0xf0 | (code >> 18)) << SHIFT[i++ & 3];
-		            blocks[i >> 2] |= (0x80 | ((code >> 12) & 0x3f)) << SHIFT[i++ & 3];
-		            blocks[i >> 2] |= (0x80 | ((code >> 6) & 0x3f)) << SHIFT[i++ & 3];
-		            blocks[i >> 2] |= (0x80 | (code & 0x3f)) << SHIFT[i++ & 3];
-		          }
-		        }
-		      }
-		      this.lastByteIndex = i;
-		      if (i >= byteCount) {
-		        this.start = i - byteCount;
-		        this.block = blocks[blockCount];
-		        for (i = 0; i < blockCount; ++i) {
-		          s[i] ^= blocks[i];
-		        }
-		        f(s);
-		        this.reset = true;
-		      } else {
-		        this.start = i;
-		      }
-		    }
-		    return this;
-		  };
-
-		  Keccak.prototype.encode = function (x, right) {
-		    var o = x & 255, n = 1;
-		    var bytes = [o];
-		    x = x >> 8;
-		    o = x & 255;
-		    while (o > 0) {
-		      bytes.unshift(o);
-		      x = x >> 8;
-		      o = x & 255;
-		      ++n;
-		    }
-		    if (right) {
-		      bytes.push(n);
-		    } else {
-		      bytes.unshift(n);
-		    }
-		    this.update(bytes);
-		    return bytes.length;
-		  };
-
-		  Keccak.prototype.encodeString = function (str) {
-		    var notString, type = typeof str;
-		    if (type !== 'string') {
-		      if (type === 'object') {
-		        if (str === null) {
-		          throw new Error(INPUT_ERROR);
-		        } else if (ARRAY_BUFFER && str.constructor === ArrayBuffer) {
-		          str = new Uint8Array(str);
-		        } else if (!Array.isArray(str)) {
-		          if (!ARRAY_BUFFER || !ArrayBuffer.isView(str)) {
-		            throw new Error(INPUT_ERROR);
-		          }
-		        }
-		      } else {
-		        throw new Error(INPUT_ERROR);
-		      }
-		      notString = true;
-		    }
-		    var bytes = 0, length = str.length;
-		    if (notString) {
-		      bytes = length;
-		    } else {
-		      for (var i = 0; i < str.length; ++i) {
-		        var code = str.charCodeAt(i);
-		        if (code < 0x80) {
-		          bytes += 1;
-		        } else if (code < 0x800) {
-		          bytes += 2;
-		        } else if (code < 0xd800 || code >= 0xe000) {
-		          bytes += 3;
-		        } else {
-		          code = 0x10000 + (((code & 0x3ff) << 10) | (str.charCodeAt(++i) & 0x3ff));
-		          bytes += 4;
-		        }
-		      }
-		    }
-		    bytes += this.encode(bytes * 8);
-		    this.update(str);
-		    return bytes;
-		  };
-
-		  Keccak.prototype.bytepad = function (strs, w) {
-		    var bytes = this.encode(w);
-		    for (var i = 0; i < strs.length; ++i) {
-		      bytes += this.encodeString(strs[i]);
-		    }
-		    var paddingBytes = w - bytes % w;
-		    var zeros = [];
-		    zeros.length = paddingBytes;
-		    this.update(zeros);
-		    return this;
-		  };
-
-		  Keccak.prototype.finalize = function () {
-		    if (this.finalized) {
-		      return;
-		    }
-		    this.finalized = true;
-		    var blocks = this.blocks, i = this.lastByteIndex, blockCount = this.blockCount, s = this.s;
-		    blocks[i >> 2] |= this.padding[i & 3];
-		    if (this.lastByteIndex === this.byteCount) {
-		      blocks[0] = blocks[blockCount];
-		      for (i = 1; i < blockCount + 1; ++i) {
-		        blocks[i] = 0;
-		      }
-		    }
-		    blocks[blockCount - 1] |= 0x80000000;
-		    for (i = 0; i < blockCount; ++i) {
-		      s[i] ^= blocks[i];
-		    }
-		    f(s);
-		  };
-
-		  Keccak.prototype.toString = Keccak.prototype.hex = function () {
-		    this.finalize();
-
-		    var blockCount = this.blockCount, s = this.s, outputBlocks = this.outputBlocks,
-		      extraBytes = this.extraBytes, i = 0, j = 0;
-		    var hex = '', block;
-		    while (j < outputBlocks) {
-		      for (i = 0; i < blockCount && j < outputBlocks; ++i, ++j) {
-		        block = s[i];
-		        hex += HEX_CHARS[(block >> 4) & 0x0F] + HEX_CHARS[block & 0x0F] +
-		          HEX_CHARS[(block >> 12) & 0x0F] + HEX_CHARS[(block >> 8) & 0x0F] +
-		          HEX_CHARS[(block >> 20) & 0x0F] + HEX_CHARS[(block >> 16) & 0x0F] +
-		          HEX_CHARS[(block >> 28) & 0x0F] + HEX_CHARS[(block >> 24) & 0x0F];
-		      }
-		      if (j % blockCount === 0) {
-		        f(s);
-		        i = 0;
-		      }
-		    }
-		    if (extraBytes) {
-		      block = s[i];
-		      hex += HEX_CHARS[(block >> 4) & 0x0F] + HEX_CHARS[block & 0x0F];
-		      if (extraBytes > 1) {
-		        hex += HEX_CHARS[(block >> 12) & 0x0F] + HEX_CHARS[(block >> 8) & 0x0F];
-		      }
-		      if (extraBytes > 2) {
-		        hex += HEX_CHARS[(block >> 20) & 0x0F] + HEX_CHARS[(block >> 16) & 0x0F];
-		      }
-		    }
-		    return hex;
-		  };
-
-		  Keccak.prototype.arrayBuffer = function () {
-		    this.finalize();
-
-		    var blockCount = this.blockCount, s = this.s, outputBlocks = this.outputBlocks,
-		      extraBytes = this.extraBytes, i = 0, j = 0;
-		    var bytes = this.outputBits >> 3;
-		    var buffer;
-		    if (extraBytes) {
-		      buffer = new ArrayBuffer((outputBlocks + 1) << 2);
-		    } else {
-		      buffer = new ArrayBuffer(bytes);
-		    }
-		    var array = new Uint32Array(buffer);
-		    while (j < outputBlocks) {
-		      for (i = 0; i < blockCount && j < outputBlocks; ++i, ++j) {
-		        array[j] = s[i];
-		      }
-		      if (j % blockCount === 0) {
-		        f(s);
-		      }
-		    }
-		    if (extraBytes) {
-		      array[i] = s[i];
-		      buffer = buffer.slice(0, bytes);
-		    }
-		    return buffer;
-		  };
-
-		  Keccak.prototype.buffer = Keccak.prototype.arrayBuffer;
-
-		  Keccak.prototype.digest = Keccak.prototype.array = function () {
-		    this.finalize();
-
-		    var blockCount = this.blockCount, s = this.s, outputBlocks = this.outputBlocks,
-		      extraBytes = this.extraBytes, i = 0, j = 0;
-		    var array = [], offset, block;
-		    while (j < outputBlocks) {
-		      for (i = 0; i < blockCount && j < outputBlocks; ++i, ++j) {
-		        offset = j << 2;
-		        block = s[i];
-		        array[offset] = block & 0xFF;
-		        array[offset + 1] = (block >> 8) & 0xFF;
-		        array[offset + 2] = (block >> 16) & 0xFF;
-		        array[offset + 3] = (block >> 24) & 0xFF;
-		      }
-		      if (j % blockCount === 0) {
-		        f(s);
-		      }
-		    }
-		    if (extraBytes) {
-		      offset = j << 2;
-		      block = s[i];
-		      array[offset] = block & 0xFF;
-		      if (extraBytes > 1) {
-		        array[offset + 1] = (block >> 8) & 0xFF;
-		      }
-		      if (extraBytes > 2) {
-		        array[offset + 2] = (block >> 16) & 0xFF;
-		      }
-		    }
-		    return array;
-		  };
-
-		  function Kmac(bits, padding, outputBits) {
-		    Keccak.call(this, bits, padding, outputBits);
-		  }
-
-		  Kmac.prototype = new Keccak();
-
-		  Kmac.prototype.finalize = function () {
-		    this.encode(this.outputBits, true);
-		    return Keccak.prototype.finalize.call(this);
-		  };
-
-		  var f = function (s) {
-		    var h, l, n, c0, c1, c2, c3, c4, c5, c6, c7, c8, c9,
-		      b0, b1, b2, b3, b4, b5, b6, b7, b8, b9, b10, b11, b12, b13, b14, b15, b16, b17,
-		      b18, b19, b20, b21, b22, b23, b24, b25, b26, b27, b28, b29, b30, b31, b32, b33,
-		      b34, b35, b36, b37, b38, b39, b40, b41, b42, b43, b44, b45, b46, b47, b48, b49;
-		    for (n = 0; n < 48; n += 2) {
-		      c0 = s[0] ^ s[10] ^ s[20] ^ s[30] ^ s[40];
-		      c1 = s[1] ^ s[11] ^ s[21] ^ s[31] ^ s[41];
-		      c2 = s[2] ^ s[12] ^ s[22] ^ s[32] ^ s[42];
-		      c3 = s[3] ^ s[13] ^ s[23] ^ s[33] ^ s[43];
-		      c4 = s[4] ^ s[14] ^ s[24] ^ s[34] ^ s[44];
-		      c5 = s[5] ^ s[15] ^ s[25] ^ s[35] ^ s[45];
-		      c6 = s[6] ^ s[16] ^ s[26] ^ s[36] ^ s[46];
-		      c7 = s[7] ^ s[17] ^ s[27] ^ s[37] ^ s[47];
-		      c8 = s[8] ^ s[18] ^ s[28] ^ s[38] ^ s[48];
-		      c9 = s[9] ^ s[19] ^ s[29] ^ s[39] ^ s[49];
-
-		      h = c8 ^ ((c2 << 1) | (c3 >>> 31));
-		      l = c9 ^ ((c3 << 1) | (c2 >>> 31));
-		      s[0] ^= h;
-		      s[1] ^= l;
-		      s[10] ^= h;
-		      s[11] ^= l;
-		      s[20] ^= h;
-		      s[21] ^= l;
-		      s[30] ^= h;
-		      s[31] ^= l;
-		      s[40] ^= h;
-		      s[41] ^= l;
-		      h = c0 ^ ((c4 << 1) | (c5 >>> 31));
-		      l = c1 ^ ((c5 << 1) | (c4 >>> 31));
-		      s[2] ^= h;
-		      s[3] ^= l;
-		      s[12] ^= h;
-		      s[13] ^= l;
-		      s[22] ^= h;
-		      s[23] ^= l;
-		      s[32] ^= h;
-		      s[33] ^= l;
-		      s[42] ^= h;
-		      s[43] ^= l;
-		      h = c2 ^ ((c6 << 1) | (c7 >>> 31));
-		      l = c3 ^ ((c7 << 1) | (c6 >>> 31));
-		      s[4] ^= h;
-		      s[5] ^= l;
-		      s[14] ^= h;
-		      s[15] ^= l;
-		      s[24] ^= h;
-		      s[25] ^= l;
-		      s[34] ^= h;
-		      s[35] ^= l;
-		      s[44] ^= h;
-		      s[45] ^= l;
-		      h = c4 ^ ((c8 << 1) | (c9 >>> 31));
-		      l = c5 ^ ((c9 << 1) | (c8 >>> 31));
-		      s[6] ^= h;
-		      s[7] ^= l;
-		      s[16] ^= h;
-		      s[17] ^= l;
-		      s[26] ^= h;
-		      s[27] ^= l;
-		      s[36] ^= h;
-		      s[37] ^= l;
-		      s[46] ^= h;
-		      s[47] ^= l;
-		      h = c6 ^ ((c0 << 1) | (c1 >>> 31));
-		      l = c7 ^ ((c1 << 1) | (c0 >>> 31));
-		      s[8] ^= h;
-		      s[9] ^= l;
-		      s[18] ^= h;
-		      s[19] ^= l;
-		      s[28] ^= h;
-		      s[29] ^= l;
-		      s[38] ^= h;
-		      s[39] ^= l;
-		      s[48] ^= h;
-		      s[49] ^= l;
-
-		      b0 = s[0];
-		      b1 = s[1];
-		      b32 = (s[11] << 4) | (s[10] >>> 28);
-		      b33 = (s[10] << 4) | (s[11] >>> 28);
-		      b14 = (s[20] << 3) | (s[21] >>> 29);
-		      b15 = (s[21] << 3) | (s[20] >>> 29);
-		      b46 = (s[31] << 9) | (s[30] >>> 23);
-		      b47 = (s[30] << 9) | (s[31] >>> 23);
-		      b28 = (s[40] << 18) | (s[41] >>> 14);
-		      b29 = (s[41] << 18) | (s[40] >>> 14);
-		      b20 = (s[2] << 1) | (s[3] >>> 31);
-		      b21 = (s[3] << 1) | (s[2] >>> 31);
-		      b2 = (s[13] << 12) | (s[12] >>> 20);
-		      b3 = (s[12] << 12) | (s[13] >>> 20);
-		      b34 = (s[22] << 10) | (s[23] >>> 22);
-		      b35 = (s[23] << 10) | (s[22] >>> 22);
-		      b16 = (s[33] << 13) | (s[32] >>> 19);
-		      b17 = (s[32] << 13) | (s[33] >>> 19);
-		      b48 = (s[42] << 2) | (s[43] >>> 30);
-		      b49 = (s[43] << 2) | (s[42] >>> 30);
-		      b40 = (s[5] << 30) | (s[4] >>> 2);
-		      b41 = (s[4] << 30) | (s[5] >>> 2);
-		      b22 = (s[14] << 6) | (s[15] >>> 26);
-		      b23 = (s[15] << 6) | (s[14] >>> 26);
-		      b4 = (s[25] << 11) | (s[24] >>> 21);
-		      b5 = (s[24] << 11) | (s[25] >>> 21);
-		      b36 = (s[34] << 15) | (s[35] >>> 17);
-		      b37 = (s[35] << 15) | (s[34] >>> 17);
-		      b18 = (s[45] << 29) | (s[44] >>> 3);
-		      b19 = (s[44] << 29) | (s[45] >>> 3);
-		      b10 = (s[6] << 28) | (s[7] >>> 4);
-		      b11 = (s[7] << 28) | (s[6] >>> 4);
-		      b42 = (s[17] << 23) | (s[16] >>> 9);
-		      b43 = (s[16] << 23) | (s[17] >>> 9);
-		      b24 = (s[26] << 25) | (s[27] >>> 7);
-		      b25 = (s[27] << 25) | (s[26] >>> 7);
-		      b6 = (s[36] << 21) | (s[37] >>> 11);
-		      b7 = (s[37] << 21) | (s[36] >>> 11);
-		      b38 = (s[47] << 24) | (s[46] >>> 8);
-		      b39 = (s[46] << 24) | (s[47] >>> 8);
-		      b30 = (s[8] << 27) | (s[9] >>> 5);
-		      b31 = (s[9] << 27) | (s[8] >>> 5);
-		      b12 = (s[18] << 20) | (s[19] >>> 12);
-		      b13 = (s[19] << 20) | (s[18] >>> 12);
-		      b44 = (s[29] << 7) | (s[28] >>> 25);
-		      b45 = (s[28] << 7) | (s[29] >>> 25);
-		      b26 = (s[38] << 8) | (s[39] >>> 24);
-		      b27 = (s[39] << 8) | (s[38] >>> 24);
-		      b8 = (s[48] << 14) | (s[49] >>> 18);
-		      b9 = (s[49] << 14) | (s[48] >>> 18);
-
-		      s[0] = b0 ^ (~b2 & b4);
-		      s[1] = b1 ^ (~b3 & b5);
-		      s[10] = b10 ^ (~b12 & b14);
-		      s[11] = b11 ^ (~b13 & b15);
-		      s[20] = b20 ^ (~b22 & b24);
-		      s[21] = b21 ^ (~b23 & b25);
-		      s[30] = b30 ^ (~b32 & b34);
-		      s[31] = b31 ^ (~b33 & b35);
-		      s[40] = b40 ^ (~b42 & b44);
-		      s[41] = b41 ^ (~b43 & b45);
-		      s[2] = b2 ^ (~b4 & b6);
-		      s[3] = b3 ^ (~b5 & b7);
-		      s[12] = b12 ^ (~b14 & b16);
-		      s[13] = b13 ^ (~b15 & b17);
-		      s[22] = b22 ^ (~b24 & b26);
-		      s[23] = b23 ^ (~b25 & b27);
-		      s[32] = b32 ^ (~b34 & b36);
-		      s[33] = b33 ^ (~b35 & b37);
-		      s[42] = b42 ^ (~b44 & b46);
-		      s[43] = b43 ^ (~b45 & b47);
-		      s[4] = b4 ^ (~b6 & b8);
-		      s[5] = b5 ^ (~b7 & b9);
-		      s[14] = b14 ^ (~b16 & b18);
-		      s[15] = b15 ^ (~b17 & b19);
-		      s[24] = b24 ^ (~b26 & b28);
-		      s[25] = b25 ^ (~b27 & b29);
-		      s[34] = b34 ^ (~b36 & b38);
-		      s[35] = b35 ^ (~b37 & b39);
-		      s[44] = b44 ^ (~b46 & b48);
-		      s[45] = b45 ^ (~b47 & b49);
-		      s[6] = b6 ^ (~b8 & b0);
-		      s[7] = b7 ^ (~b9 & b1);
-		      s[16] = b16 ^ (~b18 & b10);
-		      s[17] = b17 ^ (~b19 & b11);
-		      s[26] = b26 ^ (~b28 & b20);
-		      s[27] = b27 ^ (~b29 & b21);
-		      s[36] = b36 ^ (~b38 & b30);
-		      s[37] = b37 ^ (~b39 & b31);
-		      s[46] = b46 ^ (~b48 & b40);
-		      s[47] = b47 ^ (~b49 & b41);
-		      s[8] = b8 ^ (~b0 & b2);
-		      s[9] = b9 ^ (~b1 & b3);
-		      s[18] = b18 ^ (~b10 & b12);
-		      s[19] = b19 ^ (~b11 & b13);
-		      s[28] = b28 ^ (~b20 & b22);
-		      s[29] = b29 ^ (~b21 & b23);
-		      s[38] = b38 ^ (~b30 & b32);
-		      s[39] = b39 ^ (~b31 & b33);
-		      s[48] = b48 ^ (~b40 & b42);
-		      s[49] = b49 ^ (~b41 & b43);
-
-		      s[0] ^= RC[n];
-		      s[1] ^= RC[n + 1];
-		    }
-		  };
-
-		  if (COMMON_JS) {
-		    module.exports = methods;
-		  } else {
-		    for (i = 0; i < methodNames.length; ++i) {
-		      root[methodNames[i]] = methods[methodNames[i]];
-		    }
-		  }
-		})();
-	} (sha3$1));
-
-	var sha3 = sha3$1.exports;
+	gen(0x06, 136, 256 / 8);
+	gen(0x06, 104, 384 / 8);
+	gen(0x06, 72, 512 / 8);
+	gen(0x01, 144, 224 / 8);
+	/**
+	 * keccak-256 hash function. Different from SHA3-256.
+	 * @param message - that would be hashed
+	 */
+	const keccak_256 = gen(0x01, 136, 256 / 8);
+	gen(0x01, 104, 384 / 8);
+	gen(0x01, 72, 512 / 8);
+	const genShake = (suffix, blockLen, outputLen) => wrapConstructorWithOpts((opts = {}) => new Keccak(blockLen, suffix, opts.dkLen === undefined ? outputLen : opts.dkLen, true));
+	genShake(0x1f, 168, 128 / 8);
+	genShake(0x1f, 136, 256 / 8);
 
 	// HMAC (RFC 2104)
 	class HMAC extends Hash {
@@ -22868,7 +22915,7 @@ var solanaWeb3 = (function (exports) {
 	    assert$1(publicKey.length === PUBLIC_KEY_BYTES, `Public key must be ${PUBLIC_KEY_BYTES} bytes but received ${publicKey.length} bytes`);
 
 	    try {
-	      return buffer.Buffer.from(sha3.keccak_256.update(toBuffer(publicKey)).digest()).slice(-ETHEREUM_ADDRESS_BYTES);
+	      return buffer.Buffer.from(keccak_256(toBuffer(publicKey))).slice(-ETHEREUM_ADDRESS_BYTES);
 	    } catch (error) {
 	      throw new Error(`Error constructing Ethereum address: ${error}`);
 	    }
@@ -22968,7 +23015,7 @@ var solanaWeb3 = (function (exports) {
 	      /* isCompressed */
 	      ).slice(1); // throw away leading byte
 
-	      const messageHash = buffer.Buffer.from(sha3.keccak_256.update(toBuffer(message)).digest());
+	      const messageHash = buffer.Buffer.from(keccak_256(toBuffer(message)));
 	      const [signature, recoveryId] = ecdsaSign(messageHash, privateKey);
 	      return this.createInstructionWithPublicKey({
 	        publicKey,
@@ -23862,6 +23909,33 @@ var solanaWeb3 = (function (exports) {
 	      }
 	    };
 	  }
+	  /**
+	   * 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.
 	   */
@@ -23918,6 +23992,10 @@ var solanaWeb3 = (function (exports) {
 	  Withdraw: {
 	    index: 3,
 	    layout: struct([u32('instruction'), ns64('lamports')])
+	  },
+	  AuthorizeWithSeed: {
+	    index: 10,
+	    layout: struct([u32('instruction'), voteAuthorizeWithSeedArgs()])
 	  }
 	});
 	/**
@@ -24046,6 +24124,49 @@ var solanaWeb3 = (function (exports) {
 	      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.
 	   */
@@ -24392,6 +24513,7 @@ var solanaWeb3 = (function (exports) {
 	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;
@@ -24426,6 +24548,7 @@ var solanaWeb3 = (function (exports) {
 	exports.TransactionExpiredBlockheightExceededError = TransactionExpiredBlockheightExceededError;
 	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;