@solana/web3.js 1.53.0 → 1.54.0

package/lib/index.browser.esm.js

@@ -1769,6 +1769,11 @@ const SOLANA_SCHEMA = new Map();
  */
 
 const MAX_SEED_LENGTH = 32;
+/**
+ * Size of public key in bytes
+ */
+
+const PUBLIC_KEY_LENGTH = 32;
 /**
  * Value to be converted into public key
  */
@@ -1799,7 +1804,7 @@ class PublicKey extends Struct {
         // assume base 58 encoding by default
         const decoded = bs58.decode(value);
 
-        if (decoded.length != 32) {
+        if (decoded.length != PUBLIC_KEY_LENGTH) {
           throw new Error(`Invalid public key input`);
         }
 
@@ -1852,7 +1857,7 @@ class PublicKey extends Struct {
   toBuffer() {
     const b = this._bn.toArrayLike(Buffer);
 
-    if (b.length === 32) {
+    if (b.length === PUBLIC_KEY_LENGTH) {
       return b;
     }
 
@@ -2080,6 +2085,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 {
@@ -2112,6 +2118,13 @@ Object.defineProperty(TransactionExpiredTimeoutError.prototype, 'name', {
 const publicKey = (property = 'publicKey') => {
   return BufferLayout.blob(32, property);
 };
+/**
+ * Layout for a signature
+ */
+
+const signature = (property = 'signature') => {
+  return BufferLayout.blob(64, property);
+};
 
 /**
  * Layout for a Rust String type
@@ -2223,11 +2236,9 @@ function encodeLength(bytes, len) {
   }
 }
 
-const PUBKEY_LENGTH = 32;
 /**
  * List of instructions to be processed atomically
  */
-
 class Message {
   constructor(args) {
     this.header = void 0;
@@ -2242,6 +2253,26 @@ 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.decode(ix.data)
+    }));
+  }
+
+  get addressTableLookups() {
+    return [];
+  }
+
   isAccountSigner(index) {
     return index < this.header.numRequiredSignatures;
   }
@@ -2318,19 +2349,24 @@ class Message {
     // Slice up wire data
     let byteArray = [...buffer];
     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.encode(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 = [];
 
@@ -2371,6 +2407,182 @@ function assert (condition, message) {
   }
 }
 
+/**
+ * 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 = BufferLayout.struct([BufferLayout.u8('prefix'), BufferLayout.struct([BufferLayout.u8('numRequiredSignatures'), BufferLayout.u8('numReadonlySignedAccounts'), BufferLayout.u8('numReadonlyUnsignedAccounts')], 'header'), BufferLayout.blob(encodedStaticAccountKeysLength.length, 'staticAccountKeysLength'), BufferLayout.seq(publicKey(), this.staticAccountKeys.length, 'staticAccountKeys'), publicKey('recentBlockhash'), BufferLayout.blob(encodedInstructionsLength.length, 'instructionsLength'), BufferLayout.blob(serializedInstructions.length, 'serializedInstructions'), BufferLayout.blob(encodedAddressTableLookupsLength.length, 'addressTableLookupsLength'), BufferLayout.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.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.struct([BufferLayout.u8('programIdIndex'), BufferLayout.blob(encodedAccountKeyIndexesLength.length, 'encodedAccountKeyIndexesLength'), BufferLayout.seq(BufferLayout.u8(), instruction.accountKeyIndexes.length, 'accountKeyIndexes'), BufferLayout.blob(encodedDataLength.length, 'encodedDataLength'), BufferLayout.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.struct([publicKey('accountKey'), BufferLayout.blob(encodedWritableIndexesLength.length, 'encodedWritableIndexesLength'), BufferLayout.seq(BufferLayout.u8(), lookup.writableIndexes.length, 'writableIndexes'), BufferLayout.blob(encodedReadonlyIndexesLength.length, 'encodedReadonlyIndexesLength'), BufferLayout.seq(BufferLayout.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.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`);
+    }
+  }
+};
+
 let TransactionStatus;
 /**
  * Default (empty) signature
@@ -3099,6 +3311,70 @@ class Transaction {
 
 }
 
+/**
+ * Versioned transaction class
+ */
+class VersionedTransaction {
+  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.struct([BufferLayout.blob(encodedSignaturesLength.length, 'encodedSignaturesLength'), BufferLayout.seq(signature(), this.signatures.length, 'signatures'), BufferLayout.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] = 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');
@@ -4492,24 +4768,26 @@ const LookupTableMetaLayout = {
   BufferLayout.seq(publicKey(), BufferLayout.offset(BufferLayout.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;
@@ -4529,7 +4807,17 @@ const BLOCKHASH_CACHE_TIMEOUT_MS = 30 * 1000;
  * 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;
@@ -4724,7 +5012,7 @@ const BlockProductionResponseStruct = jsonRpcResultAndContext(type({
  * 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;
@@ -5530,8 +5818,6 @@ class Connection {
     this._subscriptionCallbacksByServerSubscriptionId = {};
     this._subscriptionsByHash = {};
     this._subscriptionsAutoDisposedByRpc = new Set();
-    let url = new URL(endpoint);
-    const useHttps = url.protocol === 'https:';
     let wsEndpoint;
     let httpHeaders;
     let fetch;
@@ -5550,9 +5836,9 @@ class Connection {
       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(this._rpcWsEndpoint, {
@@ -10093,6 +10379,23 @@ class VoteProgram {
       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');
@@ -10144,15 +10447,14 @@ class ValidatorInfo {
 
 
   static fromConfigData(buffer) {
-    const PUBKEY_LENGTH = 32;
     let byteArray = [...buffer];
     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({
@@ -10364,5 +10666,5 @@ async function sendAndConfirmRawTransaction(connection, rawTransaction, confirma
 
 const LAMPORTS_PER_SOL = 1000000000;
 
-export { Account, AddressLookupTableAccount, AddressLookupTableInstruction, AddressLookupTableProgram, Authorized, BLOCKHASH_CACHE_TIMEOUT_MS, BPF_LOADER_DEPRECATED_PROGRAM_ID, BPF_LOADER_PROGRAM_ID, BpfLoader, COMPUTE_BUDGET_INSTRUCTION_LAYOUTS, ComputeBudgetInstruction, ComputeBudgetProgram, Connection, Ed25519Program, Enum, EpochSchedule, FeeCalculatorLayout, Keypair, LAMPORTS_PER_SOL, LOOKUP_TABLE_INSTRUCTION_LAYOUTS, Loader, Lockup, MAX_SEED_LENGTH, Message, NONCE_ACCOUNT_LENGTH, NonceAccount, PACKET_DATA_SIZE, PublicKey, SIGNATURE_LENGTH_IN_BYTES, SOLANA_SCHEMA, STAKE_CONFIG_ID, STAKE_INSTRUCTION_LAYOUTS, SYSTEM_INSTRUCTION_LAYOUTS, SYSVAR_CLOCK_PUBKEY, SYSVAR_EPOCH_SCHEDULE_PUBKEY, SYSVAR_INSTRUCTIONS_PUBKEY, SYSVAR_RECENT_BLOCKHASHES_PUBKEY, SYSVAR_RENT_PUBKEY, SYSVAR_REWARDS_PUBKEY, SYSVAR_SLOT_HASHES_PUBKEY, SYSVAR_SLOT_HISTORY_PUBKEY, SYSVAR_STAKE_HISTORY_PUBKEY, Secp256k1Program, SendTransactionError, SolanaJSONRPCError, SolanaJSONRPCErrorCode, StakeAuthorizationLayout, StakeInstruction, StakeProgram, Struct, SystemInstruction, SystemProgram, Transaction, TransactionExpiredBlockheightExceededError, TransactionExpiredTimeoutError, TransactionInstruction, TransactionStatus, VALIDATOR_INFO_KEY, VOTE_PROGRAM_ID, ValidatorInfo, VoteAccount, VoteAuthorizationLayout, VoteInit, VoteInstruction, VoteProgram, clusterApiUrl, sendAndConfirmRawTransaction, sendAndConfirmTransaction };
+export { Account, AddressLookupTableAccount, AddressLookupTableInstruction, AddressLookupTableProgram, Authorized, BLOCKHASH_CACHE_TIMEOUT_MS, BPF_LOADER_DEPRECATED_PROGRAM_ID, BPF_LOADER_PROGRAM_ID, BpfLoader, COMPUTE_BUDGET_INSTRUCTION_LAYOUTS, ComputeBudgetInstruction, ComputeBudgetProgram, Connection, Ed25519Program, Enum, EpochSchedule, FeeCalculatorLayout, Keypair, LAMPORTS_PER_SOL, LOOKUP_TABLE_INSTRUCTION_LAYOUTS, Loader, Lockup, MAX_SEED_LENGTH, Message, MessageV0, NONCE_ACCOUNT_LENGTH, NonceAccount, PACKET_DATA_SIZE, PUBLIC_KEY_LENGTH, PublicKey, SIGNATURE_LENGTH_IN_BYTES, SOLANA_SCHEMA, STAKE_CONFIG_ID, STAKE_INSTRUCTION_LAYOUTS, SYSTEM_INSTRUCTION_LAYOUTS, SYSVAR_CLOCK_PUBKEY, SYSVAR_EPOCH_SCHEDULE_PUBKEY, SYSVAR_INSTRUCTIONS_PUBKEY, SYSVAR_RECENT_BLOCKHASHES_PUBKEY, SYSVAR_RENT_PUBKEY, SYSVAR_REWARDS_PUBKEY, SYSVAR_SLOT_HASHES_PUBKEY, SYSVAR_SLOT_HISTORY_PUBKEY, SYSVAR_STAKE_HISTORY_PUBKEY, Secp256k1Program, SendTransactionError, SolanaJSONRPCError, SolanaJSONRPCErrorCode, StakeAuthorizationLayout, StakeInstruction, StakeProgram, Struct, SystemInstruction, SystemProgram, Transaction, TransactionExpiredBlockheightExceededError, TransactionExpiredTimeoutError, TransactionInstruction, TransactionStatus, VALIDATOR_INFO_KEY, VERSION_PREFIX_MASK, VOTE_PROGRAM_ID, ValidatorInfo, VersionedMessage, VersionedTransaction, VoteAccount, VoteAuthorizationLayout, VoteInit, VoteInstruction, VoteProgram, clusterApiUrl, sendAndConfirmRawTransaction, sendAndConfirmTransaction };
 //# sourceMappingURL=index.browser.esm.js.map