@solana/web3.js 1.53.0 → 1.54.0

package/lib/index.iife.js

@@ -11177,6 +11177,11 @@ var solanaWeb3 = (function (exports) {
 	 */
 
 	const MAX_SEED_LENGTH = 32;
+	/**
+	 * Size of public key in bytes
+	 */
+
+	const PUBLIC_KEY_LENGTH = 32;
 	/**
 	 * Value to be converted into public key
 	 */
@@ -11207,7 +11212,7 @@ var solanaWeb3 = (function (exports) {
 	        // assume base 58 encoding by default
 	        const decoded = bs58$1.decode(value);
 
-	        if (decoded.length != 32) {
+	        if (decoded.length != PUBLIC_KEY_LENGTH) {
 	          throw new Error(`Invalid public key input`);
 	        }
 
@@ -11260,7 +11265,7 @@ var solanaWeb3 = (function (exports) {
 	  toBuffer() {
 	    const b = this._bn.toArrayLike(buffer.Buffer);
 
-	    if (b.length === 32) {
+	    if (b.length === PUBLIC_KEY_LENGTH) {
 	      return b;
 	    }
 
@@ -13771,6 +13776,7 @@ var solanaWeb3 = (function (exports) {
 	 * 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 {
@@ -13803,6 +13809,13 @@ var solanaWeb3 = (function (exports) {
 	const publicKey = (property = 'publicKey') => {
 	  return blob(32, property);
 	};
+	/**
+	 * Layout for a signature
+	 */
+
+	const signature$2 = (property = 'signature') => {
+	  return blob(64, property);
+	};
 
 	/**
 	 * Layout for a Rust String type
@@ -13914,11 +13927,9 @@ var solanaWeb3 = (function (exports) {
 	  }
 	}
 
-	const PUBKEY_LENGTH = 32;
 	/**
 	 * List of instructions to be processed atomically
 	 */
-
 	class Message {
 	  constructor(args) {
 	    this.header = void 0;
@@ -13933,6 +13944,26 @@ var solanaWeb3 = (function (exports) {
 	    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$1.decode(ix.data)
+	    }));
+	  }
+
+	  get addressTableLookups() {
+	    return [];
+	  }
+
 	  isAccountSigner(index) {
 	    return index < this.header.numRequiredSignatures;
 	  }
@@ -14009,19 +14040,24 @@ var solanaWeb3 = (function (exports) {
 	    // 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);
 	    let accountKeys = [];
 
 	    for (let i = 0; i < accountCount; i++) {
-	      const account = byteArray.slice(0, PUBKEY_LENGTH);
-	      byteArray = byteArray.slice(PUBKEY_LENGTH);
+	      const account = byteArray.slice(0, PUBLIC_KEY_LENGTH);
+	      byteArray = byteArray.slice(PUBLIC_KEY_LENGTH);
 	      accountKeys.push(bs58$1.encode(buffer.Buffer.from(account)));
 	    }
 
-	    const recentBlockhash = byteArray.slice(0, PUBKEY_LENGTH);
-	    byteArray = byteArray.slice(PUBKEY_LENGTH);
+	    const recentBlockhash = byteArray.slice(0, PUBLIC_KEY_LENGTH);
+	    byteArray = byteArray.slice(PUBLIC_KEY_LENGTH);
 	    const instructionCount = decodeLength(byteArray);
 	    let instructions = [];
 
@@ -14062,6 +14098,182 @@ var solanaWeb3 = (function (exports) {
 	  }
 	}
 
+	/**
+	 * 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;
+	  }
+
+	  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 = struct([u8('prefix'), struct([u8('numRequiredSignatures'), u8('numReadonlySignedAccounts'), u8('numReadonlyUnsignedAccounts')], 'header'), blob(encodedStaticAccountKeysLength.length, 'staticAccountKeysLength'), seq(publicKey(), this.staticAccountKeys.length, 'staticAccountKeys'), publicKey('recentBlockhash'), blob(encodedInstructionsLength.length, 'instructionsLength'), blob(serializedInstructions.length, 'serializedInstructions'), blob(encodedAddressTableLookupsLength.length, 'addressTableLookupsLength'), 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$1.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 = struct([u8('programIdIndex'), blob(encodedAccountKeyIndexesLength.length, 'encodedAccountKeyIndexesLength'), seq(u8(), instruction.accountKeyIndexes.length, 'accountKeyIndexes'), blob(encodedDataLength.length, 'encodedDataLength'), 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 = struct([publicKey('accountKey'), blob(encodedWritableIndexesLength.length, 'encodedWritableIndexesLength'), seq(u8(), lookup.writableIndexes.length, 'writableIndexes'), blob(encodedReadonlyIndexesLength.length, 'encodedReadonlyIndexesLength'), seq(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$c(prefix !== maskedPrefix, `Expected versioned message but received legacy message`);
+	    const version = maskedPrefix;
+	    assert$c(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$1.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 = {
+	  deserialize: 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 Message.from(serializedMessage);
+	    } // the lower 7 bits of the prefix indicate the message version
+
+
+	    const version = maskedPrefix;
+
+	    if (version === 0) {
+	      return MessageV0.deserialize(serializedMessage);
+	    } else {
+	      throw new Error(`Transaction message version ${version} deserialization is not supported`);
+	    }
+	  }
+	};
+
 	exports.TransactionStatus = void 0;
 	/**
 	 * Default (empty) signature
@@ -14790,6 +15002,70 @@ var solanaWeb3 = (function (exports) {
 
 	}
 
+	/**
+	 * Versioned transaction class
+	 */
+	class VersionedTransaction {
+	  constructor(message, signatures) {
+	    this.signatures = void 0;
+	    this.message = void 0;
+
+	    if (signatures !== undefined) {
+	      assert$c(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 = struct([blob(encodedSignaturesLength.length, 'encodedSignaturesLength'), seq(signature$2(), this.signatures.length, 'signatures'), 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$c(signerIndex >= 0, `Cannot sign with non signer key ${signer.publicKey.toBase58()}`);
+	      this.signatures[signerIndex] = nacl.sign.detached(messageData, signer.secretKey);
+	    }
+	  }
+
+	}
+
 	const SYSVAR_CLOCK_PUBKEY = new PublicKey('SysvarC1ock11111111111111111111111111111111');
 	const SYSVAR_EPOCH_SCHEDULE_PUBKEY = new PublicKey('SysvarEpochSchedu1e111111111111111111111111');
 	const SYSVAR_INSTRUCTIONS_PUBKEY = new PublicKey('Sysvar1nstructions1111111111111111111111111');
@@ -18484,7 +18760,7 @@ var solanaWeb3 = (function (exports) {
 	}
 
 	var DNS = '6ba7b810-9dad-11d1-80b4-00c04fd430c8';
-	var URL$1 = '6ba7b811-9dad-11d1-80b4-00c04fd430c8';
+	var URL = '6ba7b811-9dad-11d1-80b4-00c04fd430c8';
 	function v35 (name, version, hashfunc) {
 	  function generateUUID(value, namespace, buf, offset) {
 	    if (typeof value === 'string') {
@@ -18529,7 +18805,7 @@ var solanaWeb3 = (function (exports) {
 
 
 	  generateUUID.DNS = DNS;
-	  generateUUID.URL = URL$1;
+	  generateUUID.URL = URL;
 	  return generateUUID;
 	}
 
@@ -19348,24 +19624,26 @@ var solanaWeb3 = (function (exports) {
 	  seq(publicKey(), offset(u8(), -1), 'authority')])
 	};
 
-	const URL = globalThis.URL;
-
+	const URL_RE = /^[^:]+:\/\/([^:[]+|\[[^\]]+\])(:\d+)?(.*)/i;
 	function makeWebsocketUrl(endpoint) {
-	  let url = new URL(endpoint);
-	  const useHttps = url.protocol === 'https:';
-	  url.protocol = useHttps ? 'wss:' : 'ws:';
-	  url.host = ''; // Only shift the port by +1 as a convention for ws(s) only if given endpoint
+	  const matches = endpoint.match(URL_RE);
+
+	  if (matches == null) {
+	    throw TypeError(`Failed to validate endpoint URL \`${endpoint}\``);
+	  }
+
+	  const [_, // eslint-disable-line @typescript-eslint/no-unused-vars
+	  hostish, portWithColon, rest] = matches;
+	  const protocol = endpoint.startsWith('https:') ? 'wss:' : 'ws:';
+	  const startPort = portWithColon == null ? null : parseInt(portWithColon.slice(1), 10);
+	  const websocketPort = // Only shift the port by +1 as a convention for ws(s) only if given endpoint
 	  // is explictly specifying the endpoint port (HTTP-based RPC), assuming
 	  // we're directly trying to connect to solana-validator's ws listening port.
 	  // When the endpoint omits the port, we're connecting to the protocol
 	  // default ports: http(80) or https(443) and it's assumed we're behind a reverse
 	  // proxy which manages WebSocket upgrade and backend port redirection.
-
-	  if (url.port !== '') {
-	    url.port = String(Number(url.port) + 1);
-	  }
-
-	  return url.toString();
+	  startPort == null ? '' : `:${startPort + 1}`;
+	  return `${protocol}//${hostish}${websocketPort}${rest}`;
 	}
 
 	var _process$env$npm_pack;
@@ -19385,7 +19663,17 @@ var solanaWeb3 = (function (exports) {
 	 * https://gist.github.com/steveluscher/c057eca81d479ef705cdb53162f9971d
 	 */
 
+	/* @internal */
+	function assertEndpointUrl(putativeUrl) {
+	  if (/^https?:/.test(putativeUrl) === false) {
+	    throw new TypeError('Endpoint URL must start with `http:` or `https:`.');
+	  }
+
+	  return putativeUrl;
+	}
 	/** @internal */
+
+
 	function extractCommitmentFromConfig(commitmentOrConfig) {
 	  let commitment;
 	  let config;
@@ -19580,7 +19868,7 @@ var solanaWeb3 = (function (exports) {
 	 * A performance sample
 	 */
 
-	function createRpcClient(url, useHttps, httpHeaders, customFetch, fetchMiddleware, disableRetryOnRateLimit) {
+	function createRpcClient(url, httpHeaders, customFetch, fetchMiddleware, disableRetryOnRateLimit) {
 	  const fetch = customFetch ? customFetch : fetchImpl;
 
 	  let fetchWithMiddleware;
@@ -20386,8 +20674,6 @@ var solanaWeb3 = (function (exports) {
 	    this._subscriptionCallbacksByServerSubscriptionId = {};
 	    this._subscriptionsByHash = {};
 	    this._subscriptionsAutoDisposedByRpc = new Set();
-	    let url = new URL(endpoint);
-	    const useHttps = url.protocol === 'https:';
 	    let wsEndpoint;
 	    let httpHeaders;
 	    let fetch;
@@ -20406,9 +20692,9 @@ var solanaWeb3 = (function (exports) {
 	      disableRetryOnRateLimit = commitmentOrConfig.disableRetryOnRateLimit;
 	    }
 
-	    this._rpcEndpoint = endpoint;
+	    this._rpcEndpoint = assertEndpointUrl(endpoint);
 	    this._rpcWsEndpoint = wsEndpoint || makeWebsocketUrl(endpoint);
-	    this._rpcClient = createRpcClient(url.toString(), useHttps, httpHeaders, fetch, fetchMiddleware, disableRetryOnRateLimit);
+	    this._rpcClient = createRpcClient(endpoint, httpHeaders, fetch, fetchMiddleware, disableRetryOnRateLimit);
 	    this._rpcRequest = createRpcRequest(this._rpcClient);
 	    this._rpcBatchRequest = createRpcBatchRequest(this._rpcClient);
 	    this._rpcWebSocket = new Client_1(this._rpcWsEndpoint, {
@@ -30542,6 +30828,23 @@ var solanaWeb3 = (function (exports) {
 	      data
 	    });
 	  }
+	  /**
+	   * Generate a transaction to withdraw safely from a Vote account.
+	   *
+	   * This function was created as a safeguard for vote accounts running validators, `safeWithdraw`
+	   * checks that the withdraw amount will not exceed the specified balance while leaving enough left
+	   * to cover rent. If you wish to close the vote account by withdrawing the full amount, call the
+	   * `withdraw` method directly.
+	   */
+
+
+	  static safeWithdraw(params, currentVoteAccountBalance, rentExemptMinimum) {
+	    if (params.lamports > currentVoteAccountBalance - rentExemptMinimum) {
+	      throw new Error('Withdraw will leave vote account with insuffcient funds.');
+	    }
+
+	    return VoteProgram.withdraw(params);
+	  }
 
 	}
 	VoteProgram.programId = new PublicKey('Vote111111111111111111111111111111111111111');
@@ -30593,15 +30896,14 @@ var solanaWeb3 = (function (exports) {
 
 
 	  static fromConfigData(buffer$1) {
-	    const PUBKEY_LENGTH = 32;
 	    let byteArray = [...buffer$1];
 	    const configKeyCount = decodeLength(byteArray);
 	    if (configKeyCount !== 2) return null;
 	    const configKeys = [];
 
 	    for (let i = 0; i < 2; i++) {
-	      const publicKey = new PublicKey(byteArray.slice(0, PUBKEY_LENGTH));
-	      byteArray = byteArray.slice(PUBKEY_LENGTH);
+	      const publicKey = new PublicKey(byteArray.slice(0, PUBLIC_KEY_LENGTH));
+	      byteArray = byteArray.slice(PUBLIC_KEY_LENGTH);
 	      const isSigner = byteArray.slice(0, 1)[0] === 1;
 	      byteArray = byteArray.slice(1);
 	      configKeys.push({
@@ -30837,9 +31139,11 @@ var solanaWeb3 = (function (exports) {
 	exports.Lockup = Lockup;
 	exports.MAX_SEED_LENGTH = MAX_SEED_LENGTH;
 	exports.Message = Message;
+	exports.MessageV0 = MessageV0;
 	exports.NONCE_ACCOUNT_LENGTH = NONCE_ACCOUNT_LENGTH;
 	exports.NonceAccount = NonceAccount;
 	exports.PACKET_DATA_SIZE = PACKET_DATA_SIZE;
+	exports.PUBLIC_KEY_LENGTH = PUBLIC_KEY_LENGTH;
 	exports.PublicKey = PublicKey;
 	exports.SIGNATURE_LENGTH_IN_BYTES = SIGNATURE_LENGTH_IN_BYTES;
 	exports.SOLANA_SCHEMA = SOLANA_SCHEMA;
@@ -30870,8 +31174,11 @@ var solanaWeb3 = (function (exports) {
 	exports.TransactionExpiredTimeoutError = TransactionExpiredTimeoutError;
 	exports.TransactionInstruction = TransactionInstruction;
 	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;