@solana/web3.js 1.52.0 → 1.54.1

package/lib/index.d.ts

@@ -19,6 +19,10 @@ declare module '@solana/web3.js' {
    * Maximum length of derived pubkey seed
    */
   export const MAX_SEED_LENGTH = 32;
+  /**
+   * Size of public key in bytes
+   */
+  export const PUBLIC_KEY_LENGTH = 32;
   /**
    * Value to be converted into public key
    */
@@ -137,11 +141,20 @@ declare module '@solana/web3.js' {
      */
     get publicKey(): PublicKey;
     /**
-     * The **unencrypted** secret key for this account
+     * The **unencrypted** secret key for this account. The first 32 bytes
+     * is the private scalar and the last 32 bytes is the public key.
+     * Read more: https://blog.mozilla.org/warner/2011/11/29/ed25519-keys/
      */
     get secretKey(): Buffer;
   }
 
+  /**
+   * Blockhash as Base58 string.
+   */
+  export type Blockhash = string;
+
+  export const BPF_LOADER_DEPRECATED_PROGRAM_ID: PublicKey;
+
   /**
    * Epoch schedule
    * (see https://docs.solana.com/terminology#epoch)
@@ -177,11 +190,6 @@ declare module '@solana/web3.js' {
     init?: nodeFetch.RequestInit,
   ): Promise<nodeFetch.Response>;
 
-  /**
-   * Blockhash as Base58 string.
-   */
-  export type Blockhash = string;
-
   /**
    * Calculator for transaction fees.
    *
@@ -212,17 +220,24 @@ declare module '@solana/web3.js' {
   }
 
   /**
-   * Keypair signer interface
+   * A 64 byte secret key, the first 32 bytes of which is the
+   * private scalar and the last 32 bytes is the public key.
+   * Read more: https://blog.mozilla.org/warner/2011/11/29/ed25519-keys/
    */
-  interface Signer {
-    publicKey: PublicKey;
-    secretKey: Uint8Array;
-  }
+  export type Ed25519SecretKey = Uint8Array;
   /**
    * Ed25519 Keypair
    */
   interface Ed25519Keypair {
     publicKey: Uint8Array;
+    secretKey: Ed25519SecretKey;
+  }
+
+  /**
+   * Keypair signer interface
+   */
+  interface Signer {
+    publicKey: PublicKey;
     secretKey: Uint8Array;
   }
   /**
@@ -276,19 +291,25 @@ declare module '@solana/web3.js' {
   }
 
   /**
-   * The message header, identifying signed and read-only account
+   * Maximum over-the-wire size of a Transaction
+   *
+   * 1280 is IPv6 minimum MTU
+   * 40 bytes is the size of the IPv6 header
+   * 8 bytes is the size of the fragment header
    */
-  export type MessageHeader = {
-    /**
-     * The number of signatures required for this message to be considered valid. The
-     * signatures must match the first `numRequiredSignatures` of `accountKeys`.
-     */
-    numRequiredSignatures: number;
-    /** The last `numReadonlySignedAccounts` of the signed keys are read-only accounts */
-    numReadonlySignedAccounts: number;
-    /** The last `numReadonlySignedAccounts` of the unsigned keys are read-only accounts */
-    numReadonlyUnsignedAccounts: number;
-  };
+  export const PACKET_DATA_SIZE: number;
+  export const VERSION_PREFIX_MASK = 127;
+  export const SIGNATURE_LENGTH_IN_BYTES = 64;
+
+  export class TransactionExpiredBlockheightExceededError extends Error {
+    signature: string;
+    constructor(signature: string);
+  }
+  export class TransactionExpiredTimeoutError extends Error {
+    signature: string;
+    constructor(signature: string, timeoutSeconds: number);
+  }
+
   /**
    * An instruction to execute by a program
    *
@@ -327,6 +348,10 @@ declare module '@solana/web3.js' {
     instructions: CompiledInstruction[];
     private indexToProgramIds;
     constructor(args: MessageArgs);
+    get version(): 'legacy';
+    get staticAccountKeys(): Array<PublicKey>;
+    get compiledInstructions(): Array<MessageCompiledInstruction>;
+    get addressTableLookups(): Array<MessageAddressTableLookup>;
     isAccountSigner(index: number): boolean;
     isAccountWritable(index: number): boolean;
     isProgramId(index: number): boolean;
@@ -339,243 +364,564 @@ declare module '@solana/web3.js' {
     static from(buffer: Buffer | Uint8Array | Array<number>): Message;
   }
 
-  export type ClientSubscriptionId = number;
-  export type TokenAccountsFilter =
-    | {
-        mint: PublicKey;
-      }
-    | {
-        programId: PublicKey;
-      };
-  /**
-   * Extra contextual information for RPC responses
-   */
-  export type Context = {
-    slot: number;
-  };
   /**
-   * Options for sending transactions
+   * Message constructor arguments
    */
-  export type SendOptions = {
-    /** disable transaction verification step */
-    skipPreflight?: boolean;
-    /** preflight commitment level */
-    preflightCommitment?: Commitment;
-    /** Maximum number of times for the RPC node to retry sending the transaction to the leader. */
-    maxRetries?: number;
-    /** The minimum slot that the request can be evaluated at */
-    minContextSlot?: number;
+  export type MessageV0Args = {
+    /** The message header, identifying signed and read-only `accountKeys` */
+    header: MessageHeader;
+    /** The static account keys used by this transaction */
+    staticAccountKeys: PublicKey[];
+    /** The hash of a recent ledger block */
+    recentBlockhash: Blockhash;
+    /** Instructions that will be executed in sequence and committed in one atomic transaction if all succeed. */
+    compiledInstructions: MessageCompiledInstruction[];
+    /** Instructions that will be executed in sequence and committed in one atomic transaction if all succeed. */
+    addressTableLookups: MessageAddressTableLookup[];
   };
-  /**
-   * Options for confirming transactions
-   */
-  export type ConfirmOptions = {
-    /** disable transaction verification step */
-    skipPreflight?: boolean;
-    /** desired commitment level */
-    commitment?: Commitment;
-    /** preflight commitment level */
-    preflightCommitment?: Commitment;
-    /** Maximum number of times for the RPC node to retry sending the transaction to the leader. */
-    maxRetries?: number;
-    /** The minimum slot that the request can be evaluated at */
-    minContextSlot?: number;
+  export class MessageV0 {
+    header: MessageHeader;
+    staticAccountKeys: Array<PublicKey>;
+    recentBlockhash: Blockhash;
+    compiledInstructions: Array<MessageCompiledInstruction>;
+    addressTableLookups: Array<MessageAddressTableLookup>;
+    constructor(args: MessageV0Args);
+    get version(): 0;
+    serialize(): Uint8Array;
+    private serializeInstructions;
+    private serializeAddressTableLookups;
+    static deserialize(serializedMessage: Uint8Array): MessageV0;
+  }
+
+  export type VersionedMessage = Message | MessageV0;
+  export const VersionedMessage: {
+    deserialize: (serializedMessage: Uint8Array) => VersionedMessage;
   };
+
   /**
-   * Options for getConfirmedSignaturesForAddress2
+   * The message header, identifying signed and read-only account
    */
-  export type ConfirmedSignaturesForAddress2Options = {
+  export type MessageHeader = {
     /**
-     * Start searching backwards from this transaction signature.
-     * @remark If not provided the search starts from the highest max confirmed block.
+     * The number of signatures required for this message to be considered valid. The
+     * signatures must match the first `numRequiredSignatures` of `accountKeys`.
      */
-    before?: TransactionSignature;
-    /** Search until this transaction signature is reached, if found before `limit`. */
-    until?: TransactionSignature;
-    /** Maximum transaction signatures to return (between 1 and 1,000, default: 1,000). */
-    limit?: number;
+    numRequiredSignatures: number;
+    /** The last `numReadonlySignedAccounts` of the signed keys are read-only accounts */
+    numReadonlySignedAccounts: number;
+    /** The last `numReadonlySignedAccounts` of the unsigned keys are read-only accounts */
+    numReadonlyUnsignedAccounts: number;
   };
   /**
-   * Options for getSignaturesForAddress
+   * An address table lookup used to load additional accounts
    */
-  export type SignaturesForAddressOptions = {
-    /**
-     * Start searching backwards from this transaction signature.
-     * @remark If not provided the search starts from the highest max confirmed block.
-     */
-    before?: TransactionSignature;
-    /** Search until this transaction signature is reached, if found before `limit`. */
-    until?: TransactionSignature;
-    /** Maximum transaction signatures to return (between 1 and 1,000, default: 1,000). */
-    limit?: number;
-    /** The minimum slot that the request can be evaluated at */
-    minContextSlot?: number;
+  export type MessageAddressTableLookup = {
+    accountKey: PublicKey;
+    writableIndexes: Array<number>;
+    readonlyIndexes: Array<number>;
   };
   /**
-   * RPC Response with extra contextual information
+   * An instruction to execute by a program
+   *
+   * @property {number} programIdIndex
+   * @property {number[]} accountKeyIndexes
+   * @property {Uint8Array} data
    */
-  export type RpcResponseAndContext<T> = {
-    /** response context */
-    context: Context;
-    /** response value */
-    value: T;
+  export type MessageCompiledInstruction = {
+    /** Index into the transaction keys array indicating the program account that executes this instruction */
+    programIdIndex: number;
+    /** Ordered indices into the transaction keys array indicating which accounts to pass to the program */
+    accountKeyIndexes: number[];
+    /** The program input data */
+    data: Uint8Array;
   };
-  export type BlockhashWithExpiryBlockHeight = Readonly<{
-    blockhash: Blockhash;
-    lastValidBlockHeight: number;
-  }>;
-  /**
-   * A strategy for confirming transactions that uses the last valid
-   * block height for a given blockhash to check for transaction expiration.
-   */
-  export type BlockheightBasedTransactionConfirmationStrategy = {
-    signature: TransactionSignature;
-  } & BlockhashWithExpiryBlockHeight;
+
   /**
-   * The level of commitment desired when querying state
-   * <pre>
-   *   'processed': Query the most recent block which has reached 1 confirmation by the connected node
-   *   'confirmed': Query the most recent block which has reached 1 confirmation by the cluster
-   *   'finalized': Query the most recent block which has been finalized by the cluster
-   * </pre>
+   * Transaction signature as base-58 encoded string
    */
-  export type Commitment =
-    | 'processed'
-    | 'confirmed'
-    | 'finalized'
-    | 'recent'
-    | 'single'
-    | 'singleGossip'
-    | 'root'
-    | 'max';
+  export type TransactionSignature = string;
+  export const enum TransactionStatus {
+    BLOCKHEIGHT_EXCEEDED = 0,
+    PROCESSED = 1,
+    TIMED_OUT = 2,
+  }
   /**
-   * A subset of Commitment levels, which are at least optimistically confirmed
-   * <pre>
-   *   'confirmed': Query the most recent block which has reached 1 confirmation by the cluster
-   *   'finalized': Query the most recent block which has been finalized by the cluster
-   * </pre>
+   * Account metadata used to define instructions
    */
-  export type Finality = 'confirmed' | 'finalized';
+  export type AccountMeta = {
+    /** An account's public key */
+    pubkey: PublicKey;
+    /** True if an instruction requires a transaction signature matching `pubkey` */
+    isSigner: boolean;
+    /** True if the `pubkey` can be loaded as a read-write account. */
+    isWritable: boolean;
+  };
   /**
-   * Filter for largest accounts query
-   * <pre>
-   *   'circulating':    Return the largest accounts that are part of the circulating supply
-   *   'nonCirculating': Return the largest accounts that are not part of the circulating supply
-   * </pre>
+   * List of TransactionInstruction object fields that may be initialized at construction
    */
-  export type LargestAccountsFilter = 'circulating' | 'nonCirculating';
+  export type TransactionInstructionCtorFields = {
+    keys: Array<AccountMeta>;
+    programId: PublicKey;
+    data?: Buffer;
+  };
   /**
-   * Configuration object for changing `getAccountInfo` query behavior
+   * Configuration object for Transaction.serialize()
    */
-  export type GetAccountInfoConfig = {
-    /** The level of commitment desired */
-    commitment?: Commitment;
-    /** The minimum slot that the request can be evaluated at */
-    minContextSlot?: number;
+  export type SerializeConfig = {
+    /** Require all transaction signatures be present (default: true) */
+    requireAllSignatures?: boolean;
+    /** Verify provided signatures (default: true) */
+    verifySignatures?: boolean;
   };
   /**
-   * Configuration object for changing `getBalance` query behavior
+   * Transaction Instruction class
    */
-  export type GetBalanceConfig = {
-    /** The level of commitment desired */
-    commitment?: Commitment;
-    /** The minimum slot that the request can be evaluated at */
-    minContextSlot?: number;
-  };
+  export class TransactionInstruction {
+    /**
+     * Public keys to include in this transaction
+     * Boolean represents whether this pubkey needs to sign the transaction
+     */
+    keys: Array<AccountMeta>;
+    /**
+     * Program Id to execute
+     */
+    programId: PublicKey;
+    /**
+     * Program input
+     */
+    data: Buffer;
+    constructor(opts: TransactionInstructionCtorFields);
+  }
   /**
-   * Configuration object for changing `getBlock` query behavior
+   * Pair of signature and corresponding public key
    */
-  export type GetBlockConfig = {
-    /** The level of finality desired */
-    commitment?: Finality;
-    /** The max transaction version to return in responses. If the requested transaction is a higher version, an error will be returned */
-    maxSupportedTransactionVersion?: number;
+  export type SignaturePubkeyPair = {
+    signature: Buffer | null;
+    publicKey: PublicKey;
   };
   /**
-   * Configuration object for changing `getStakeMinimumDelegation` query behavior
+   * List of Transaction object fields that may be initialized at construction
    */
-  export type GetStakeMinimumDelegationConfig = {
-    /** The level of commitment desired */
-    commitment?: Commitment;
+  export type TransactionCtorFields_DEPRECATED = {
+    /** Optional nonce information used for offline nonce'd transactions */
+    nonceInfo?: NonceInformation | null;
+    /** The transaction fee payer */
+    feePayer?: PublicKey | null;
+    /** One or more signatures */
+    signatures?: Array<SignaturePubkeyPair>;
+    /** A recent blockhash */
+    recentBlockhash?: Blockhash;
   };
+  export type TransactionCtorFields = TransactionCtorFields_DEPRECATED;
   /**
-   * Configuration object for changing `getBlockHeight` query behavior
+   * List of Transaction object fields that may be initialized at construction
    */
-  export type GetBlockHeightConfig = {
-    /** The level of commitment desired */
-    commitment?: Commitment;
-    /** The minimum slot that the request can be evaluated at */
-    minContextSlot?: number;
+  export type TransactionBlockhashCtor = {
+    /** The transaction fee payer */
+    feePayer?: PublicKey | null;
+    /** One or more signatures */
+    signatures?: Array<SignaturePubkeyPair>;
+    /** A recent blockhash */
+    blockhash: Blockhash;
+    /** the last block chain can advance to before tx is exportd expired */
+    lastValidBlockHeight: number;
   };
   /**
-   * Configuration object for changing `getEpochInfo` query behavior
+   * Nonce information to be used to build an offline Transaction.
    */
-  export type GetEpochInfoConfig = {
-    /** The level of commitment desired */
-    commitment?: Commitment;
-    /** The minimum slot that the request can be evaluated at */
-    minContextSlot?: number;
+  export type NonceInformation = {
+    /** The current blockhash stored in the nonce */
+    nonce: Blockhash;
+    /** AdvanceNonceAccount Instruction */
+    nonceInstruction: TransactionInstruction;
   };
   /**
-   * Configuration object for changing `getInflationReward` query behavior
+   * Transaction class
    */
-  export type GetInflationRewardConfig = {
-    /** The level of commitment desired */
-    commitment?: Commitment;
-    /** An epoch for which the reward occurs. If omitted, the previous epoch will be used */
-    epoch?: number;
-    /** The minimum slot that the request can be evaluated at */
-    minContextSlot?: number;
+  export class Transaction {
+    /**
+     * Signatures for the transaction.  Typically created by invoking the
+     * `sign()` method
+     */
+    signatures: Array<SignaturePubkeyPair>;
+    /**
+     * The first (payer) Transaction signature
+     */
+    get signature(): Buffer | null;
+    /**
+     * The transaction fee payer
+     */
+    feePayer?: PublicKey;
+    /**
+     * The instructions to atomically execute
+     */
+    instructions: Array<TransactionInstruction>;
+    /**
+     * A recent transaction id. Must be populated by the caller
+     */
+    recentBlockhash?: Blockhash;
+    /**
+     * the last block chain can advance to before tx is exportd expired
+     * */
+    lastValidBlockHeight?: number;
+    /**
+     * Optional Nonce information. If populated, transaction will use a durable
+     * Nonce hash instead of a recentBlockhash. Must be populated by the caller
+     */
+    nonceInfo?: NonceInformation;
+    constructor(opts?: TransactionBlockhashCtor);
+    /**
+     * @deprecated `TransactionCtorFields` has been deprecated and will be removed in a future version.
+     * Please supply a `TransactionBlockhashCtor` instead.
+     */
+    constructor(opts?: TransactionCtorFields_DEPRECATED);
+    /**
+     * Add one or more instructions to this Transaction
+     */
+    add(
+      ...items: Array<
+        Transaction | TransactionInstruction | TransactionInstructionCtorFields
+      >
+    ): Transaction;
+    /**
+     * Compile transaction data
+     */
+    compileMessage(): Message;
+    /**
+     * Get a buffer of the Transaction data that need to be covered by signatures
+     */
+    serializeMessage(): Buffer;
+    /**
+     * Get the estimated fee associated with a transaction
+     */
+    getEstimatedFee(connection: Connection): Promise<number>;
+    /**
+     * Specify the public keys which will be used to sign the Transaction.
+     * The first signer will be used as the transaction fee payer account.
+     *
+     * Signatures can be added with either `partialSign` or `addSignature`
+     *
+     * @deprecated Deprecated since v0.84.0. Only the fee payer needs to be
+     * specified and it can be set in the Transaction constructor or with the
+     * `feePayer` property.
+     */
+    setSigners(...signers: Array<PublicKey>): void;
+    /**
+     * Sign the Transaction with the specified signers. Multiple signatures may
+     * be applied to a Transaction. The first signature is considered "primary"
+     * and is used identify and confirm transactions.
+     *
+     * If the Transaction `feePayer` is not set, the first signer will be used
+     * as the transaction fee payer account.
+     *
+     * Transaction fields should not be modified after the first call to `sign`,
+     * as doing so may invalidate the signature and cause the Transaction to be
+     * rejected.
+     *
+     * The Transaction must be assigned a valid `recentBlockhash` before invoking this method
+     */
+    sign(...signers: Array<Signer>): void;
+    /**
+     * Partially sign a transaction with the specified accounts. All accounts must
+     * correspond to either the fee payer or a signer account in the transaction
+     * instructions.
+     *
+     * All the caveats from the `sign` method apply to `partialSign`
+     */
+    partialSign(...signers: Array<Signer>): void;
+    /**
+     * Add an externally created signature to a transaction. The public key
+     * must correspond to either the fee payer or a signer account in the transaction
+     * instructions.
+     */
+    addSignature(pubkey: PublicKey, signature: Buffer): void;
+    /**
+     * Verify signatures of a complete, signed Transaction
+     */
+    verifySignatures(): boolean;
+    /**
+     * Serialize the Transaction in the wire format.
+     */
+    serialize(config?: SerializeConfig): Buffer;
+    /**
+     * Parse a wire transaction into a Transaction object.
+     */
+    static from(buffer: Buffer | Uint8Array | Array<number>): Transaction;
+    /**
+     * Populate Transaction object from message and signatures
+     */
+    static populate(message: Message, signatures?: Array<string>): Transaction;
+  }
+
+  export type TransactionVersion = 'legacy' | 0;
+  /**
+   * Versioned transaction class
+   */
+  export class VersionedTransaction {
+    signatures: Array<Uint8Array>;
+    message: VersionedMessage;
+    constructor(message: VersionedMessage, signatures?: Array<Uint8Array>);
+    serialize(): Uint8Array;
+    static deserialize(serializedTransaction: Uint8Array): VersionedTransaction;
+    sign(signers: Array<Signer>): void;
+  }
+
+  export type AddressLookupTableState = {
+    deactivationSlot: bigint;
+    lastExtendedSlot: number;
+    lastExtendedSlotStartIndex: number;
+    authority?: PublicKey;
+    addresses: Array<PublicKey>;
+  };
+  export type AddressLookupTableAccountArgs = {
+    key: PublicKey;
+    state: AddressLookupTableState;
   };
+  export class AddressLookupTableAccount {
+    key: PublicKey;
+    state: AddressLookupTableState;
+    constructor(args: AddressLookupTableAccountArgs);
+    isActive(): boolean;
+    static deserialize(accountData: Uint8Array): AddressLookupTableState;
+  }
+
+  export type ClientSubscriptionId = number;
+  export type TokenAccountsFilter =
+    | {
+        mint: PublicKey;
+      }
+    | {
+        programId: PublicKey;
+      };
   /**
-   * Configuration object for changing `getLatestBlockhash` query behavior
+   * Extra contextual information for RPC responses
    */
-  export type GetLatestBlockhashConfig = {
-    /** The level of commitment desired */
-    commitment?: Commitment;
-    /** The minimum slot that the request can be evaluated at */
-    minContextSlot?: number;
+  export type Context = {
+    slot: number;
   };
   /**
-   * Configuration object for changing `getSlot` query behavior
+   * Options for sending transactions
    */
-  export type GetSlotConfig = {
-    /** The level of commitment desired */
-    commitment?: Commitment;
+  export type SendOptions = {
+    /** disable transaction verification step */
+    skipPreflight?: boolean;
+    /** preflight commitment level */
+    preflightCommitment?: Commitment;
+    /** Maximum number of times for the RPC node to retry sending the transaction to the leader. */
+    maxRetries?: number;
     /** The minimum slot that the request can be evaluated at */
     minContextSlot?: number;
   };
   /**
-   * Configuration object for changing `getSlotLeader` query behavior
+   * Options for confirming transactions
    */
-  export type GetSlotLeaderConfig = {
-    /** The level of commitment desired */
+  export type ConfirmOptions = {
+    /** disable transaction verification step */
+    skipPreflight?: boolean;
+    /** desired commitment level */
     commitment?: Commitment;
+    /** preflight commitment level */
+    preflightCommitment?: Commitment;
+    /** Maximum number of times for the RPC node to retry sending the transaction to the leader. */
+    maxRetries?: number;
     /** The minimum slot that the request can be evaluated at */
     minContextSlot?: number;
   };
   /**
-   * Configuration object for changing `getTransaction` query behavior
+   * Options for getConfirmedSignaturesForAddress2
    */
-  export type GetTransactionConfig = {
-    /** The level of finality desired */
-    commitment?: Finality;
-    /** The max transaction version to return in responses. If the requested transaction is a higher version, an error will be returned */
-    maxSupportedTransactionVersion?: number;
+  export type ConfirmedSignaturesForAddress2Options = {
+    /**
+     * Start searching backwards from this transaction signature.
+     * @remark If not provided the search starts from the highest max confirmed block.
+     */
+    before?: TransactionSignature;
+    /** Search until this transaction signature is reached, if found before `limit`. */
+    until?: TransactionSignature;
+    /** Maximum transaction signatures to return (between 1 and 1,000, default: 1,000). */
+    limit?: number;
   };
   /**
-   * Configuration object for changing `getLargestAccounts` query behavior
+   * Options for getSignaturesForAddress
    */
-  export type GetLargestAccountsConfig = {
-    /** The level of commitment desired */
-    commitment?: Commitment;
-    /** Filter largest accounts by whether they are part of the circulating supply */
-    filter?: LargestAccountsFilter;
+  export type SignaturesForAddressOptions = {
+    /**
+     * Start searching backwards from this transaction signature.
+     * @remark If not provided the search starts from the highest max confirmed block.
+     */
+    before?: TransactionSignature;
+    /** Search until this transaction signature is reached, if found before `limit`. */
+    until?: TransactionSignature;
+    /** Maximum transaction signatures to return (between 1 and 1,000, default: 1,000). */
+    limit?: number;
+    /** The minimum slot that the request can be evaluated at */
+    minContextSlot?: number;
   };
   /**
-   * Configuration object for changing `getSupply` request behavior
+   * RPC Response with extra contextual information
    */
-  export type GetSupplyConfig = {
+  export type RpcResponseAndContext<T> = {
+    /** response context */
+    context: Context;
+    /** response value */
+    value: T;
+  };
+  export type BlockhashWithExpiryBlockHeight = Readonly<{
+    blockhash: Blockhash;
+    lastValidBlockHeight: number;
+  }>;
+  /**
+   * A strategy for confirming transactions that uses the last valid
+   * block height for a given blockhash to check for transaction expiration.
+   */
+  export type BlockheightBasedTransactionConfirmationStrategy = {
+    signature: TransactionSignature;
+  } & BlockhashWithExpiryBlockHeight;
+  /**
+   * The level of commitment desired when querying state
+   * <pre>
+   *   'processed': Query the most recent block which has reached 1 confirmation by the connected node
+   *   'confirmed': Query the most recent block which has reached 1 confirmation by the cluster
+   *   'finalized': Query the most recent block which has been finalized by the cluster
+   * </pre>
+   */
+  export type Commitment =
+    | 'processed'
+    | 'confirmed'
+    | 'finalized'
+    | 'recent'
+    | 'single'
+    | 'singleGossip'
+    | 'root'
+    | 'max';
+  /**
+   * A subset of Commitment levels, which are at least optimistically confirmed
+   * <pre>
+   *   'confirmed': Query the most recent block which has reached 1 confirmation by the cluster
+   *   'finalized': Query the most recent block which has been finalized by the cluster
+   * </pre>
+   */
+  export type Finality = 'confirmed' | 'finalized';
+  /**
+   * Filter for largest accounts query
+   * <pre>
+   *   'circulating':    Return the largest accounts that are part of the circulating supply
+   *   'nonCirculating': Return the largest accounts that are not part of the circulating supply
+   * </pre>
+   */
+  export type LargestAccountsFilter = 'circulating' | 'nonCirculating';
+  /**
+   * Configuration object for changing `getAccountInfo` query behavior
+   */
+  export type GetAccountInfoConfig = {
+    /** The level of commitment desired */
+    commitment?: Commitment;
+    /** The minimum slot that the request can be evaluated at */
+    minContextSlot?: number;
+  };
+  /**
+   * Configuration object for changing `getBalance` query behavior
+   */
+  export type GetBalanceConfig = {
+    /** The level of commitment desired */
+    commitment?: Commitment;
+    /** The minimum slot that the request can be evaluated at */
+    minContextSlot?: number;
+  };
+  /**
+   * Configuration object for changing `getBlock` query behavior
+   */
+  export type GetBlockConfig = {
+    /** The level of finality desired */
+    commitment?: Finality;
+    /** The max transaction version to return in responses. If the requested transaction is a higher version, an error will be returned */
+    maxSupportedTransactionVersion?: number;
+  };
+  /**
+   * Configuration object for changing `getStakeMinimumDelegation` query behavior
+   */
+  export type GetStakeMinimumDelegationConfig = {
+    /** The level of commitment desired */
+    commitment?: Commitment;
+  };
+  /**
+   * Configuration object for changing `getBlockHeight` query behavior
+   */
+  export type GetBlockHeightConfig = {
+    /** The level of commitment desired */
+    commitment?: Commitment;
+    /** The minimum slot that the request can be evaluated at */
+    minContextSlot?: number;
+  };
+  /**
+   * Configuration object for changing `getEpochInfo` query behavior
+   */
+  export type GetEpochInfoConfig = {
+    /** The level of commitment desired */
+    commitment?: Commitment;
+    /** The minimum slot that the request can be evaluated at */
+    minContextSlot?: number;
+  };
+  /**
+   * Configuration object for changing `getInflationReward` query behavior
+   */
+  export type GetInflationRewardConfig = {
+    /** The level of commitment desired */
+    commitment?: Commitment;
+    /** An epoch for which the reward occurs. If omitted, the previous epoch will be used */
+    epoch?: number;
+    /** The minimum slot that the request can be evaluated at */
+    minContextSlot?: number;
+  };
+  /**
+   * Configuration object for changing `getLatestBlockhash` query behavior
+   */
+  export type GetLatestBlockhashConfig = {
+    /** The level of commitment desired */
+    commitment?: Commitment;
+    /** The minimum slot that the request can be evaluated at */
+    minContextSlot?: number;
+  };
+  /**
+   * Configuration object for changing `getSlot` query behavior
+   */
+  export type GetSlotConfig = {
+    /** The level of commitment desired */
+    commitment?: Commitment;
+    /** The minimum slot that the request can be evaluated at */
+    minContextSlot?: number;
+  };
+  /**
+   * Configuration object for changing `getSlotLeader` query behavior
+   */
+  export type GetSlotLeaderConfig = {
+    /** The level of commitment desired */
+    commitment?: Commitment;
+    /** The minimum slot that the request can be evaluated at */
+    minContextSlot?: number;
+  };
+  /**
+   * Configuration object for changing `getTransaction` query behavior
+   */
+  export type GetTransactionConfig = {
+    /** The level of finality desired */
+    commitment?: Finality;
+    /** The max transaction version to return in responses. If the requested transaction is a higher version, an error will be returned */
+    maxSupportedTransactionVersion?: number;
+  };
+  /**
+   * Configuration object for changing `getLargestAccounts` query behavior
+   */
+  export type GetLargestAccountsConfig = {
+    /** The level of commitment desired */
+    commitment?: Commitment;
+    /** Filter largest accounts by whether they are part of the circulating supply */
+    filter?: LargestAccountsFilter;
+  };
+  /**
+   * Configuration object for changing `getSupply` request behavior
+   */
+  export type GetSupplyConfig = {
     /** The level of commitment desired */
     commitment?: Commitment;
     /** Exclude non circulating accounts list from response */
@@ -1917,6 +2263,10 @@ declare module '@solana/web3.js' {
       options?: SignaturesForAddressOptions,
       commitment?: Finality,
     ): Promise<Array<ConfirmedSignatureInfo>>;
+    getAddressLookupTable(
+      accountKey: PublicKey,
+      config?: GetAccountInfoConfig,
+    ): Promise<RpcResponseAndContext<AddressLookupTableAccount | null>>;
     /**
      * Fetch the contents of a Nonce account from the cluster, return with context
      */
@@ -1980,379 +2330,268 @@ declare module '@solana/web3.js' {
       options?: SendOptions,
     ): Promise<TransactionSignature>;
     /**
-     * Send a transaction that has already been signed, serialized into the
-     * wire format, and encoded as a base64 string
-     */
-    sendEncodedTransaction(
-      encodedTransaction: string,
-      options?: SendOptions,
-    ): Promise<TransactionSignature>;
-    /**
-     * Register a callback to be invoked whenever the specified account changes
-     *
-     * @param publicKey Public key of the account to monitor
-     * @param callback Function to invoke whenever the account is changed
-     * @param commitment Specify the commitment level account changes must reach before notification
-     * @return subscription id
-     */
-    onAccountChange(
-      publicKey: PublicKey,
-      callback: AccountChangeCallback,
-      commitment?: Commitment,
-    ): ClientSubscriptionId;
-    /**
-     * Deregister an account notification callback
-     *
-     * @param id client subscription id to deregister
-     */
-    removeAccountChangeListener(
-      clientSubscriptionId: ClientSubscriptionId,
-    ): Promise<void>;
-    /**
-     * Register a callback to be invoked whenever accounts owned by the
-     * specified program change
-     *
-     * @param programId Public key of the program to monitor
-     * @param callback Function to invoke whenever the account is changed
-     * @param commitment Specify the commitment level account changes must reach before notification
-     * @param filters The program account filters to pass into the RPC method
-     * @return subscription id
-     */
-    onProgramAccountChange(
-      programId: PublicKey,
-      callback: ProgramAccountChangeCallback,
-      commitment?: Commitment,
-      filters?: GetProgramAccountsFilter[],
-    ): ClientSubscriptionId;
-    /**
-     * Deregister an account notification callback
-     *
-     * @param id client subscription id to deregister
-     */
-    removeProgramAccountChangeListener(
-      clientSubscriptionId: ClientSubscriptionId,
-    ): Promise<void>;
-    /**
-     * Registers a callback to be invoked whenever logs are emitted.
-     */
-    onLogs(
-      filter: LogsFilter,
-      callback: LogsCallback,
-      commitment?: Commitment,
-    ): ClientSubscriptionId;
-    /**
-     * Deregister a logs callback.
-     *
-     * @param id client subscription id to deregister.
-     */
-    removeOnLogsListener(
-      clientSubscriptionId: ClientSubscriptionId,
-    ): Promise<void>;
-    /**
-     * Register a callback to be invoked upon slot changes
-     *
-     * @param callback Function to invoke whenever the slot changes
-     * @return subscription id
-     */
-    onSlotChange(callback: SlotChangeCallback): ClientSubscriptionId;
-    /**
-     * Deregister a slot notification callback
-     *
-     * @param id client subscription id to deregister
-     */
-    removeSlotChangeListener(
-      clientSubscriptionId: ClientSubscriptionId,
-    ): Promise<void>;
-    /**
-     * Register a callback to be invoked upon slot updates. {@link SlotUpdate}'s
-     * may be useful to track live progress of a cluster.
-     *
-     * @param callback Function to invoke whenever the slot updates
-     * @return subscription id
-     */
-    onSlotUpdate(callback: SlotUpdateCallback): ClientSubscriptionId;
-    /**
-     * Deregister a slot update notification callback
-     *
-     * @param id client subscription id to deregister
-     */
-    removeSlotUpdateListener(
-      clientSubscriptionId: ClientSubscriptionId,
-    ): Promise<void>;
-    _buildArgs(
-      args: Array<any>,
-      override?: Commitment,
-      encoding?: 'jsonParsed' | 'base64',
-      extra?: any,
-    ): Array<any>;
-    /**
-     * Register a callback to be invoked upon signature updates
-     *
-     * @param signature Transaction signature string in base 58
-     * @param callback Function to invoke on signature notifications
-     * @param commitment Specify the commitment level signature must reach before notification
-     * @return subscription id
-     */
-    onSignature(
-      signature: TransactionSignature,
-      callback: SignatureResultCallback,
-      commitment?: Commitment,
-    ): ClientSubscriptionId;
-    /**
-     * Register a callback to be invoked when a transaction is
-     * received and/or processed.
-     *
-     * @param signature Transaction signature string in base 58
-     * @param callback Function to invoke on signature notifications
-     * @param options Enable received notifications and set the commitment
-     *   level that signature must reach before notification
-     * @return subscription id
-     */
-    onSignatureWithOptions(
-      signature: TransactionSignature,
-      callback: SignatureSubscriptionCallback,
-      options?: SignatureSubscriptionOptions,
-    ): ClientSubscriptionId;
-    /**
-     * Deregister a signature notification callback
-     *
-     * @param id client subscription id to deregister
-     */
-    removeSignatureListener(
-      clientSubscriptionId: ClientSubscriptionId,
-    ): Promise<void>;
-    /**
-     * Register a callback to be invoked upon root changes
-     *
-     * @param callback Function to invoke whenever the root changes
-     * @return subscription id
-     */
-    onRootChange(callback: RootChangeCallback): ClientSubscriptionId;
-    /**
-     * Deregister a root notification callback
-     *
-     * @param id client subscription id to deregister
-     */
-    removeRootChangeListener(
-      clientSubscriptionId: ClientSubscriptionId,
-    ): Promise<void>;
-  }
-
-  /**
-   * Transaction signature as base-58 encoded string
-   */
-  export type TransactionSignature = string;
-  export const enum TransactionStatus {
-    BLOCKHEIGHT_EXCEEDED = 0,
-    PROCESSED = 1,
-    TIMED_OUT = 2,
-  }
-  /**
-   * Account metadata used to define instructions
-   */
-  export type AccountMeta = {
-    /** An account's public key */
-    pubkey: PublicKey;
-    /** True if an instruction requires a transaction signature matching `pubkey` */
-    isSigner: boolean;
-    /** True if the `pubkey` can be loaded as a read-write account. */
-    isWritable: boolean;
-  };
-  /**
-   * List of TransactionInstruction object fields that may be initialized at construction
-   */
-  export type TransactionInstructionCtorFields = {
-    keys: Array<AccountMeta>;
-    programId: PublicKey;
-    data?: Buffer;
-  };
-  /**
-   * Configuration object for Transaction.serialize()
-   */
-  export type SerializeConfig = {
-    /** Require all transaction signatures be present (default: true) */
-    requireAllSignatures?: boolean;
-    /** Verify provided signatures (default: true) */
-    verifySignatures?: boolean;
-  };
-  /**
-   * Transaction Instruction class
-   */
-  export class TransactionInstruction {
-    /**
-     * Public keys to include in this transaction
-     * Boolean represents whether this pubkey needs to sign the transaction
-     */
-    keys: Array<AccountMeta>;
-    /**
-     * Program Id to execute
-     */
-    programId: PublicKey;
-    /**
-     * Program input
-     */
-    data: Buffer;
-    constructor(opts: TransactionInstructionCtorFields);
-  }
-  /**
-   * Pair of signature and corresponding public key
-   */
-  export type SignaturePubkeyPair = {
-    signature: Buffer | null;
-    publicKey: PublicKey;
-  };
-  /**
-   * List of Transaction object fields that may be initialized at construction
-   */
-  export type TransactionCtorFields_DEPRECATED = {
-    /** Optional nonce information used for offline nonce'd transactions */
-    nonceInfo?: NonceInformation | null;
-    /** The transaction fee payer */
-    feePayer?: PublicKey | null;
-    /** One or more signatures */
-    signatures?: Array<SignaturePubkeyPair>;
-    /** A recent blockhash */
-    recentBlockhash?: Blockhash;
-  };
-  export type TransactionCtorFields = TransactionCtorFields_DEPRECATED;
-  /**
-   * List of Transaction object fields that may be initialized at construction
-   */
-  export type TransactionBlockhashCtor = {
-    /** The transaction fee payer */
-    feePayer?: PublicKey | null;
-    /** One or more signatures */
-    signatures?: Array<SignaturePubkeyPair>;
-    /** A recent blockhash */
-    blockhash: Blockhash;
-    /** the last block chain can advance to before tx is exportd expired */
-    lastValidBlockHeight: number;
-  };
-  /**
-   * Nonce information to be used to build an offline Transaction.
-   */
-  export type NonceInformation = {
-    /** The current blockhash stored in the nonce */
-    nonce: Blockhash;
-    /** AdvanceNonceAccount Instruction */
-    nonceInstruction: TransactionInstruction;
-  };
-  /**
-   * Transaction class
-   */
-  export class Transaction {
-    /**
-     * Signatures for the transaction.  Typically created by invoking the
-     * `sign()` method
-     */
-    signatures: Array<SignaturePubkeyPair>;
-    /**
-     * The first (payer) Transaction signature
+     * Send a transaction that has already been signed, serialized into the
+     * wire format, and encoded as a base64 string
      */
-    get signature(): Buffer | null;
+    sendEncodedTransaction(
+      encodedTransaction: string,
+      options?: SendOptions,
+    ): Promise<TransactionSignature>;
     /**
-     * The transaction fee payer
+     * Register a callback to be invoked whenever the specified account changes
+     *
+     * @param publicKey Public key of the account to monitor
+     * @param callback Function to invoke whenever the account is changed
+     * @param commitment Specify the commitment level account changes must reach before notification
+     * @return subscription id
      */
-    feePayer?: PublicKey;
+    onAccountChange(
+      publicKey: PublicKey,
+      callback: AccountChangeCallback,
+      commitment?: Commitment,
+    ): ClientSubscriptionId;
     /**
-     * The instructions to atomically execute
+     * Deregister an account notification callback
+     *
+     * @param id client subscription id to deregister
      */
-    instructions: Array<TransactionInstruction>;
+    removeAccountChangeListener(
+      clientSubscriptionId: ClientSubscriptionId,
+    ): Promise<void>;
     /**
-     * A recent transaction id. Must be populated by the caller
+     * Register a callback to be invoked whenever accounts owned by the
+     * specified program change
+     *
+     * @param programId Public key of the program to monitor
+     * @param callback Function to invoke whenever the account is changed
+     * @param commitment Specify the commitment level account changes must reach before notification
+     * @param filters The program account filters to pass into the RPC method
+     * @return subscription id
      */
-    recentBlockhash?: Blockhash;
-    /**
-     * the last block chain can advance to before tx is exportd expired
-     * */
-    lastValidBlockHeight?: number;
+    onProgramAccountChange(
+      programId: PublicKey,
+      callback: ProgramAccountChangeCallback,
+      commitment?: Commitment,
+      filters?: GetProgramAccountsFilter[],
+    ): ClientSubscriptionId;
     /**
-     * Optional Nonce information. If populated, transaction will use a durable
-     * Nonce hash instead of a recentBlockhash. Must be populated by the caller
+     * Deregister an account notification callback
+     *
+     * @param id client subscription id to deregister
      */
-    nonceInfo?: NonceInformation;
-    constructor(opts?: TransactionBlockhashCtor);
+    removeProgramAccountChangeListener(
+      clientSubscriptionId: ClientSubscriptionId,
+    ): Promise<void>;
     /**
-     * @deprecated `TransactionCtorFields` has been deprecated and will be removed in a future version.
-     * Please supply a `TransactionBlockhashCtor` instead.
+     * Registers a callback to be invoked whenever logs are emitted.
      */
-    constructor(opts?: TransactionCtorFields_DEPRECATED);
+    onLogs(
+      filter: LogsFilter,
+      callback: LogsCallback,
+      commitment?: Commitment,
+    ): ClientSubscriptionId;
     /**
-     * Add one or more instructions to this Transaction
+     * Deregister a logs callback.
+     *
+     * @param id client subscription id to deregister.
      */
-    add(
-      ...items: Array<
-        Transaction | TransactionInstruction | TransactionInstructionCtorFields
-      >
-    ): Transaction;
+    removeOnLogsListener(
+      clientSubscriptionId: ClientSubscriptionId,
+    ): Promise<void>;
     /**
-     * Compile transaction data
+     * Register a callback to be invoked upon slot changes
+     *
+     * @param callback Function to invoke whenever the slot changes
+     * @return subscription id
      */
-    compileMessage(): Message;
+    onSlotChange(callback: SlotChangeCallback): ClientSubscriptionId;
     /**
-     * Get a buffer of the Transaction data that need to be covered by signatures
+     * Deregister a slot notification callback
+     *
+     * @param id client subscription id to deregister
      */
-    serializeMessage(): Buffer;
+    removeSlotChangeListener(
+      clientSubscriptionId: ClientSubscriptionId,
+    ): Promise<void>;
     /**
-     * Get the estimated fee associated with a transaction
+     * Register a callback to be invoked upon slot updates. {@link SlotUpdate}'s
+     * may be useful to track live progress of a cluster.
+     *
+     * @param callback Function to invoke whenever the slot updates
+     * @return subscription id
      */
-    getEstimatedFee(connection: Connection): Promise<number>;
+    onSlotUpdate(callback: SlotUpdateCallback): ClientSubscriptionId;
     /**
-     * Specify the public keys which will be used to sign the Transaction.
-     * The first signer will be used as the transaction fee payer account.
+     * Deregister a slot update notification callback
      *
-     * Signatures can be added with either `partialSign` or `addSignature`
+     * @param id client subscription id to deregister
+     */
+    removeSlotUpdateListener(
+      clientSubscriptionId: ClientSubscriptionId,
+    ): Promise<void>;
+    _buildArgs(
+      args: Array<any>,
+      override?: Commitment,
+      encoding?: 'jsonParsed' | 'base64',
+      extra?: any,
+    ): Array<any>;
+    /**
+     * Register a callback to be invoked upon signature updates
      *
-     * @deprecated Deprecated since v0.84.0. Only the fee payer needs to be
-     * specified and it can be set in the Transaction constructor or with the
-     * `feePayer` property.
+     * @param signature Transaction signature string in base 58
+     * @param callback Function to invoke on signature notifications
+     * @param commitment Specify the commitment level signature must reach before notification
+     * @return subscription id
      */
-    setSigners(...signers: Array<PublicKey>): void;
+    onSignature(
+      signature: TransactionSignature,
+      callback: SignatureResultCallback,
+      commitment?: Commitment,
+    ): ClientSubscriptionId;
     /**
-     * Sign the Transaction with the specified signers. Multiple signatures may
-     * be applied to a Transaction. The first signature is considered "primary"
-     * and is used identify and confirm transactions.
+     * Register a callback to be invoked when a transaction is
+     * received and/or processed.
      *
-     * If the Transaction `feePayer` is not set, the first signer will be used
-     * as the transaction fee payer account.
+     * @param signature Transaction signature string in base 58
+     * @param callback Function to invoke on signature notifications
+     * @param options Enable received notifications and set the commitment
+     *   level that signature must reach before notification
+     * @return subscription id
+     */
+    onSignatureWithOptions(
+      signature: TransactionSignature,
+      callback: SignatureSubscriptionCallback,
+      options?: SignatureSubscriptionOptions,
+    ): ClientSubscriptionId;
+    /**
+     * Deregister a signature notification callback
      *
-     * Transaction fields should not be modified after the first call to `sign`,
-     * as doing so may invalidate the signature and cause the Transaction to be
-     * rejected.
+     * @param id client subscription id to deregister
+     */
+    removeSignatureListener(
+      clientSubscriptionId: ClientSubscriptionId,
+    ): Promise<void>;
+    /**
+     * Register a callback to be invoked upon root changes
      *
-     * The Transaction must be assigned a valid `recentBlockhash` before invoking this method
+     * @param callback Function to invoke whenever the root changes
+     * @return subscription id
      */
-    sign(...signers: Array<Signer>): void;
+    onRootChange(callback: RootChangeCallback): ClientSubscriptionId;
     /**
-     * Partially sign a transaction with the specified accounts. All accounts must
-     * correspond to either the fee payer or a signer account in the transaction
-     * instructions.
+     * Deregister a root notification callback
      *
-     * All the caveats from the `sign` method apply to `partialSign`
+     * @param id client subscription id to deregister
      */
-    partialSign(...signers: Array<Signer>): void;
+    removeRootChangeListener(
+      clientSubscriptionId: ClientSubscriptionId,
+    ): Promise<void>;
+  }
+
+  export const BPF_LOADER_PROGRAM_ID: PublicKey;
+  /**
+   * Factory class for transactions to interact with a program loader
+   */
+  export class BpfLoader {
     /**
-     * Add an externally created signature to a transaction. The public key
-     * must correspond to either the fee payer or a signer account in the transaction
-     * instructions.
+     * Minimum number of signatures required to load a program not including
+     * retries
+     *
+     * Can be used to calculate transaction fees
      */
-    addSignature(pubkey: PublicKey, signature: Buffer): void;
+    static getMinNumSignatures(dataLength: number): number;
     /**
-     * Verify signatures of a complete, signed Transaction
+     * Load a BPF program
+     *
+     * @param connection The connection to use
+     * @param payer Account that will pay program loading fees
+     * @param program Account to load the program into
+     * @param elf The entire ELF containing the BPF program
+     * @param loaderProgramId The program id of the BPF loader to use
+     * @return true if program was loaded successfully, false if program was already loaded
      */
-    verifySignatures(): boolean;
+    static load(
+      connection: Connection,
+      payer: Signer,
+      program: Signer,
+      elf: Buffer | Uint8Array | Array<number>,
+      loaderProgramId: PublicKey,
+    ): Promise<boolean>;
+  }
+
+  export class SendTransactionError extends Error {
+    logs: string[] | undefined;
+    constructor(message: string, logs?: string[]);
+  }
+  export const SolanaJSONRPCErrorCode: {
+    readonly JSON_RPC_SERVER_ERROR_BLOCK_CLEANED_UP: -32001;
+    readonly JSON_RPC_SERVER_ERROR_SEND_TRANSACTION_PREFLIGHT_FAILURE: -32002;
+    readonly JSON_RPC_SERVER_ERROR_TRANSACTION_SIGNATURE_VERIFICATION_FAILURE: -32003;
+    readonly JSON_RPC_SERVER_ERROR_BLOCK_NOT_AVAILABLE: -32004;
+    readonly JSON_RPC_SERVER_ERROR_NODE_UNHEALTHY: -32005;
+    readonly JSON_RPC_SERVER_ERROR_TRANSACTION_PRECOMPILE_VERIFICATION_FAILURE: -32006;
+    readonly JSON_RPC_SERVER_ERROR_SLOT_SKIPPED: -32007;
+    readonly JSON_RPC_SERVER_ERROR_NO_SNAPSHOT: -32008;
+    readonly JSON_RPC_SERVER_ERROR_LONG_TERM_STORAGE_SLOT_SKIPPED: -32009;
+    readonly JSON_RPC_SERVER_ERROR_KEY_EXCLUDED_FROM_SECONDARY_INDEX: -32010;
+    readonly JSON_RPC_SERVER_ERROR_TRANSACTION_HISTORY_NOT_AVAILABLE: -32011;
+    readonly JSON_RPC_SCAN_ERROR: -32012;
+    readonly JSON_RPC_SERVER_ERROR_TRANSACTION_SIGNATURE_LEN_MISMATCH: -32013;
+    readonly JSON_RPC_SERVER_ERROR_BLOCK_STATUS_NOT_AVAILABLE_YET: -32014;
+    readonly JSON_RPC_SERVER_ERROR_UNSUPPORTED_TRANSACTION_VERSION: -32015;
+    readonly JSON_RPC_SERVER_ERROR_MIN_CONTEXT_SLOT_NOT_REACHED: -32016;
+  };
+  export type SolanaJSONRPCErrorCodeEnum =
+    typeof SolanaJSONRPCErrorCode[keyof typeof SolanaJSONRPCErrorCode];
+  export class SolanaJSONRPCError extends Error {
+    code: SolanaJSONRPCErrorCodeEnum | unknown;
+    data?: any;
+    constructor(
+      {
+        code,
+        message,
+        data,
+      }: Readonly<{
+        code: unknown;
+        message: string;
+        data?: any;
+      }>,
+      customMessage?: string,
+    );
+  }
+
+  /**
+   * Program loader interface
+   */
+  export class Loader {
     /**
-     * Serialize the Transaction in the wire format.
+     * Amount of program data placed in each load Transaction
      */
-    serialize(config?: SerializeConfig): Buffer;
+    static chunkSize: number;
     /**
-     * Parse a wire transaction into a Transaction object.
+     * Minimum number of signatures required to load a program not including
+     * retries
+     *
+     * Can be used to calculate transaction fees
      */
-    static from(buffer: Buffer | Uint8Array | Array<number>): Transaction;
+    static getMinNumSignatures(dataLength: number): number;
     /**
-     * Populate Transaction object from message and signatures
+     * Loads a generic program
+     *
+     * @param connection The connection to use
+     * @param payer System account that pays to load the program
+     * @param program Account to load the program into
+     * @param programId Public key that identifies the loader
+     * @param data Program octets
+     * @return true if program was loaded successfully, false if program was already loaded
      */
-    static populate(message: Message, signatures?: Array<string>): Transaction;
+    static load(
+      connection: Connection,
+      payer: Signer,
+      program: Signer,
+      programId: PublicKey,
+      data: Buffer | Uint8Array | Array<number>,
+    ): Promise<boolean>;
   }
 
   export type CreateLookupTableParams = {
@@ -2442,39 +2681,6 @@ declare module '@solana/web3.js' {
     ): TransactionInstruction;
   }
 
-  export const BPF_LOADER_DEPRECATED_PROGRAM_ID: PublicKey;
-
-  export const BPF_LOADER_PROGRAM_ID: PublicKey;
-  /**
-   * Factory class for transactions to interact with a program loader
-   */
-  export class BpfLoader {
-    /**
-     * Minimum number of signatures required to load a program not including
-     * retries
-     *
-     * Can be used to calculate transaction fees
-     */
-    static getMinNumSignatures(dataLength: number): number;
-    /**
-     * Load a BPF program
-     *
-     * @param connection The connection to use
-     * @param payer Account that will pay program loading fees
-     * @param program Account to load the program into
-     * @param elf The entire ELF containing the BPF program
-     * @param loaderProgramId The program id of the BPF loader to use
-     * @return true if program was loaded successfully, false if program was already loaded
-     */
-    static load(
-      connection: Connection,
-      payer: Signer,
-      program: Signer,
-      elf: Buffer | Uint8Array | Array<number>,
-      loaderProgramId: PublicKey,
-    ): Promise<boolean>;
-  }
-
   /**
    * Compute Budget Instruction class
    */
@@ -2608,37 +2814,66 @@ declare module '@solana/web3.js' {
   }
 
   /**
-   * Program loader interface
+   * Params for creating an secp256k1 instruction using a public key
    */
-  export class Loader {
+  export type CreateSecp256k1InstructionWithPublicKeyParams = {
+    publicKey: Buffer | Uint8Array | Array<number>;
+    message: Buffer | Uint8Array | Array<number>;
+    signature: Buffer | Uint8Array | Array<number>;
+    recoveryId: number;
+    instructionIndex?: number;
+  };
+  /**
+   * Params for creating an secp256k1 instruction using an Ethereum address
+   */
+  export type CreateSecp256k1InstructionWithEthAddressParams = {
+    ethAddress: Buffer | Uint8Array | Array<number> | string;
+    message: Buffer | Uint8Array | Array<number>;
+    signature: Buffer | Uint8Array | Array<number>;
+    recoveryId: number;
+    instructionIndex?: number;
+  };
+  /**
+   * Params for creating an secp256k1 instruction using a private key
+   */
+  export type CreateSecp256k1InstructionWithPrivateKeyParams = {
+    privateKey: Buffer | Uint8Array | Array<number>;
+    message: Buffer | Uint8Array | Array<number>;
+    instructionIndex?: number;
+  };
+  export class Secp256k1Program {
     /**
-     * Amount of program data placed in each load Transaction
+     * Public key that identifies the secp256k1 program
      */
-    static chunkSize: number;
+    static programId: PublicKey;
     /**
-     * Minimum number of signatures required to load a program not including
-     * retries
-     *
-     * Can be used to calculate transaction fees
+     * Construct an Ethereum address from a secp256k1 public key buffer.
+     * @param {Buffer} publicKey a 64 byte secp256k1 public key buffer
      */
-    static getMinNumSignatures(dataLength: number): number;
+    static publicKeyToEthAddress(
+      publicKey: Buffer | Uint8Array | Array<number>,
+    ): Buffer;
     /**
-     * Loads a generic program
-     *
-     * @param connection The connection to use
-     * @param payer System account that pays to load the program
-     * @param program Account to load the program into
-     * @param programId Public key that identifies the loader
-     * @param data Program octets
-     * @return true if program was loaded successfully, false if program was already loaded
+     * Create an secp256k1 instruction with a public key. The public key
+     * must be a buffer that is 64 bytes long.
      */
-    static load(
-      connection: Connection,
-      payer: Signer,
-      program: Signer,
-      programId: PublicKey,
-      data: Buffer | Uint8Array | Array<number>,
-    ): Promise<boolean>;
+    static createInstructionWithPublicKey(
+      params: CreateSecp256k1InstructionWithPublicKeyParams,
+    ): TransactionInstruction;
+    /**
+     * Create an secp256k1 instruction with an Ethereum address. The address
+     * must be a hex string or a buffer that is 20 bytes long.
+     */
+    static createInstructionWithEthAddress(
+      params: CreateSecp256k1InstructionWithEthAddressParams,
+    ): TransactionInstruction;
+    /**
+     * Create an secp256k1 instruction with a private key. The private key
+     * must be a buffer that is 32 bytes long.
+     */
+    static createInstructionWithPrivateKey(
+      params: CreateSecp256k1InstructionWithPrivateKeyParams,
+    ): TransactionInstruction;
   }
 
   /**
@@ -3291,190 +3526,22 @@ declare module '@solana/web3.js' {
     /**
      * Generate an instruction to advance the nonce in a Nonce account
      */
-    static nonceAdvance(params: AdvanceNonceParams): TransactionInstruction;
-    /**
-     * Generate a transaction instruction that withdraws lamports from a Nonce account
-     */
-    static nonceWithdraw(params: WithdrawNonceParams): TransactionInstruction;
-    /**
-     * Generate a transaction instruction that authorizes a new PublicKey as the authority
-     * on a Nonce account.
-     */
-    static nonceAuthorize(params: AuthorizeNonceParams): TransactionInstruction;
-    /**
-     * Generate a transaction instruction that allocates space in an account without funding
-     */
-    static allocate(
-      params: AllocateParams | AllocateWithSeedParams,
-    ): TransactionInstruction;
-  }
-
-  /**
-   * Params for creating an secp256k1 instruction using a public key
-   */
-  export type CreateSecp256k1InstructionWithPublicKeyParams = {
-    publicKey: Buffer | Uint8Array | Array<number>;
-    message: Buffer | Uint8Array | Array<number>;
-    signature: Buffer | Uint8Array | Array<number>;
-    recoveryId: number;
-    instructionIndex?: number;
-  };
-  /**
-   * Params for creating an secp256k1 instruction using an Ethereum address
-   */
-  export type CreateSecp256k1InstructionWithEthAddressParams = {
-    ethAddress: Buffer | Uint8Array | Array<number> | string;
-    message: Buffer | Uint8Array | Array<number>;
-    signature: Buffer | Uint8Array | Array<number>;
-    recoveryId: number;
-    instructionIndex?: number;
-  };
-  /**
-   * Params for creating an secp256k1 instruction using a private key
-   */
-  export type CreateSecp256k1InstructionWithPrivateKeyParams = {
-    privateKey: Buffer | Uint8Array | Array<number>;
-    message: Buffer | Uint8Array | Array<number>;
-    instructionIndex?: number;
-  };
-  export class Secp256k1Program {
-    /**
-     * Public key that identifies the secp256k1 program
-     */
-    static programId: PublicKey;
-    /**
-     * Construct an Ethereum address from a secp256k1 public key buffer.
-     * @param {Buffer} publicKey a 64 byte secp256k1 public key buffer
-     */
-    static publicKeyToEthAddress(
-      publicKey: Buffer | Uint8Array | Array<number>,
-    ): Buffer;
-    /**
-     * Create an secp256k1 instruction with a public key. The public key
-     * must be a buffer that is 64 bytes long.
-     */
-    static createInstructionWithPublicKey(
-      params: CreateSecp256k1InstructionWithPublicKeyParams,
-    ): TransactionInstruction;
-    /**
-     * Create an secp256k1 instruction with an Ethereum address. The address
-     * must be a hex string or a buffer that is 20 bytes long.
-     */
-    static createInstructionWithEthAddress(
-      params: CreateSecp256k1InstructionWithEthAddressParams,
-    ): TransactionInstruction;
-    /**
-     * Create an secp256k1 instruction with a private key. The private key
-     * must be a buffer that is 32 bytes long.
-     */
-    static createInstructionWithPrivateKey(
-      params: CreateSecp256k1InstructionWithPrivateKeyParams,
-    ): TransactionInstruction;
-  }
-
-  /**
-   * Maximum over-the-wire size of a Transaction
-   *
-   * 1280 is IPv6 minimum MTU
-   * 40 bytes is the size of the IPv6 header
-   * 8 bytes is the size of the fragment header
-   */
-  export const PACKET_DATA_SIZE: number;
-  export const SIGNATURE_LENGTH_IN_BYTES = 64;
-
-  export const VALIDATOR_INFO_KEY: PublicKey;
-  /**
-   * Info used to identity validators.
-   */
-  export type Info = {
-    /** validator name */
-    name: string;
-    /** optional, validator website */
-    website?: string;
-    /** optional, extra information the validator chose to share */
-    details?: string;
-    /** optional, used to identify validators on keybase.io */
-    keybaseUsername?: string;
-  };
-  /**
-   * ValidatorInfo class
-   */
-  export class ValidatorInfo {
-    /**
-     * validator public key
-     */
-    key: PublicKey;
-    /**
-     * validator information
-     */
-    info: Info;
+    static nonceAdvance(params: AdvanceNonceParams): TransactionInstruction;
     /**
-     * Construct a valid ValidatorInfo
-     *
-     * @param key validator public key
-     * @param info validator information
+     * Generate a transaction instruction that withdraws lamports from a Nonce account
      */
-    constructor(key: PublicKey, info: Info);
+    static nonceWithdraw(params: WithdrawNonceParams): TransactionInstruction;
     /**
-     * Deserialize ValidatorInfo from the config account data. Exactly two config
-     * keys are required in the data.
-     *
-     * @param buffer config account data
-     * @return null if info was not found
+     * Generate a transaction instruction that authorizes a new PublicKey as the authority
+     * on a Nonce account.
      */
-    static fromConfigData(
-      buffer: Buffer | Uint8Array | Array<number>,
-    ): ValidatorInfo | null;
-  }
-
-  export const VOTE_PROGRAM_ID: PublicKey;
-  export type Lockout = {
-    slot: number;
-    confirmationCount: number;
-  };
-  /**
-   * History of how many credits earned by the end of each epoch
-   */
-  export type EpochCredits = Readonly<{
-    epoch: number;
-    credits: number;
-    prevCredits: number;
-  }>;
-  export type AuthorizedVoter = Readonly<{
-    epoch: number;
-    authorizedVoter: PublicKey;
-  }>;
-  export type PriorVoter = Readonly<{
-    authorizedPubkey: PublicKey;
-    epochOfLastAuthorizedSwitch: number;
-    targetEpoch: number;
-  }>;
-  export type BlockTimestamp = Readonly<{
-    slot: number;
-    timestamp: number;
-  }>;
-  /**
-   * VoteAccount class
-   */
-  export class VoteAccount {
-    nodePubkey: PublicKey;
-    authorizedWithdrawer: PublicKey;
-    commission: number;
-    rootSlot: number | null;
-    votes: Lockout[];
-    authorizedVoters: AuthorizedVoter[];
-    priorVoters: PriorVoter[];
-    epochCredits: EpochCredits[];
-    lastTimestamp: BlockTimestamp;
+    static nonceAuthorize(params: AuthorizeNonceParams): TransactionInstruction;
     /**
-     * Deserialize VoteAccount from the account data.
-     *
-     * @param buffer account data
-     * @return VoteAccount
+     * Generate a transaction instruction that allocates space in an account without funding
      */
-    static fromAccountData(
-      buffer: Buffer | Uint8Array | Array<number>,
-    ): VoteAccount;
+    static allocate(
+      params: AllocateParams | AllocateWithSeedParams,
+    ): TransactionInstruction;
   }
 
   /**
@@ -3616,6 +3683,114 @@ declare module '@solana/web3.js' {
      * Generate a transaction to withdraw from a Vote account.
      */
     static withdraw(params: WithdrawFromVoteAccountParams): Transaction;
+    /**
+     * 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: WithdrawFromVoteAccountParams,
+      currentVoteAccountBalance: number,
+      rentExemptMinimum: number,
+    ): Transaction;
+  }
+
+  export const VALIDATOR_INFO_KEY: PublicKey;
+  /**
+   * Info used to identity validators.
+   */
+  export type Info = {
+    /** validator name */
+    name: string;
+    /** optional, validator website */
+    website?: string;
+    /** optional, extra information the validator chose to share */
+    details?: string;
+    /** optional, used to identify validators on keybase.io */
+    keybaseUsername?: string;
+  };
+  /**
+   * ValidatorInfo class
+   */
+  export class ValidatorInfo {
+    /**
+     * validator public key
+     */
+    key: PublicKey;
+    /**
+     * validator information
+     */
+    info: Info;
+    /**
+     * Construct a valid ValidatorInfo
+     *
+     * @param key validator public key
+     * @param info validator information
+     */
+    constructor(key: PublicKey, info: Info);
+    /**
+     * Deserialize ValidatorInfo from the config account data. Exactly two config
+     * keys are required in the data.
+     *
+     * @param buffer config account data
+     * @return null if info was not found
+     */
+    static fromConfigData(
+      buffer: Buffer | Uint8Array | Array<number>,
+    ): ValidatorInfo | null;
+  }
+
+  export const VOTE_PROGRAM_ID: PublicKey;
+  export type Lockout = {
+    slot: number;
+    confirmationCount: number;
+  };
+  /**
+   * History of how many credits earned by the end of each epoch
+   */
+  export type EpochCredits = Readonly<{
+    epoch: number;
+    credits: number;
+    prevCredits: number;
+  }>;
+  export type AuthorizedVoter = Readonly<{
+    epoch: number;
+    authorizedVoter: PublicKey;
+  }>;
+  export type PriorVoter = Readonly<{
+    authorizedPubkey: PublicKey;
+    epochOfLastAuthorizedSwitch: number;
+    targetEpoch: number;
+  }>;
+  export type BlockTimestamp = Readonly<{
+    slot: number;
+    timestamp: number;
+  }>;
+  /**
+   * VoteAccount class
+   */
+  export class VoteAccount {
+    nodePubkey: PublicKey;
+    authorizedWithdrawer: PublicKey;
+    commission: number;
+    rootSlot: number | null;
+    votes: Lockout[];
+    authorizedVoters: AuthorizedVoter[];
+    priorVoters: PriorVoter[];
+    epochCredits: EpochCredits[];
+    lastTimestamp: BlockTimestamp;
+    /**
+     * Deserialize VoteAccount from the account data.
+     *
+     * @param buffer account data
+     * @return VoteAccount
+     */
+    static fromAccountData(
+      buffer: Buffer | Uint8Array | Array<number>,
+    ): VoteAccount;
   }
 
   export const SYSVAR_CLOCK_PUBKEY: PublicKey;
@@ -3628,64 +3803,11 @@ declare module '@solana/web3.js' {
   export const SYSVAR_SLOT_HISTORY_PUBKEY: PublicKey;
   export const SYSVAR_STAKE_HISTORY_PUBKEY: PublicKey;
 
-  export class SendTransactionError extends Error {
-    logs: string[] | undefined;
-    constructor(message: string, logs?: string[]);
-  }
-  export const SolanaJSONRPCErrorCode: {
-    readonly JSON_RPC_SERVER_ERROR_BLOCK_CLEANED_UP: -32001;
-    readonly JSON_RPC_SERVER_ERROR_SEND_TRANSACTION_PREFLIGHT_FAILURE: -32002;
-    readonly JSON_RPC_SERVER_ERROR_TRANSACTION_SIGNATURE_VERIFICATION_FAILURE: -32003;
-    readonly JSON_RPC_SERVER_ERROR_BLOCK_NOT_AVAILABLE: -32004;
-    readonly JSON_RPC_SERVER_ERROR_NODE_UNHEALTHY: -32005;
-    readonly JSON_RPC_SERVER_ERROR_TRANSACTION_PRECOMPILE_VERIFICATION_FAILURE: -32006;
-    readonly JSON_RPC_SERVER_ERROR_SLOT_SKIPPED: -32007;
-    readonly JSON_RPC_SERVER_ERROR_NO_SNAPSHOT: -32008;
-    readonly JSON_RPC_SERVER_ERROR_LONG_TERM_STORAGE_SLOT_SKIPPED: -32009;
-    readonly JSON_RPC_SERVER_ERROR_KEY_EXCLUDED_FROM_SECONDARY_INDEX: -32010;
-    readonly JSON_RPC_SERVER_ERROR_TRANSACTION_HISTORY_NOT_AVAILABLE: -32011;
-    readonly JSON_RPC_SCAN_ERROR: -32012;
-    readonly JSON_RPC_SERVER_ERROR_TRANSACTION_SIGNATURE_LEN_MISMATCH: -32013;
-    readonly JSON_RPC_SERVER_ERROR_BLOCK_STATUS_NOT_AVAILABLE_YET: -32014;
-    readonly JSON_RPC_SERVER_ERROR_UNSUPPORTED_TRANSACTION_VERSION: -32015;
-    readonly JSON_RPC_SERVER_ERROR_MIN_CONTEXT_SLOT_NOT_REACHED: -32016;
-  };
-  export type SolanaJSONRPCErrorCodeEnum =
-    typeof SolanaJSONRPCErrorCode[keyof typeof SolanaJSONRPCErrorCode];
-  export class SolanaJSONRPCError extends Error {
-    code: SolanaJSONRPCErrorCodeEnum | unknown;
-    data?: any;
-    constructor(
-      {
-        code,
-        message,
-        data,
-      }: Readonly<{
-        code: unknown;
-        message: string;
-        data?: any;
-      }>,
-      customMessage?: string,
-    );
-  }
-
+  export type Cluster = 'devnet' | 'testnet' | 'mainnet-beta';
   /**
-   * Sign, send and confirm a transaction.
-   *
-   * If `commitment` option is not specified, defaults to 'max' commitment.
-   *
-   * @param {Connection} connection
-   * @param {Transaction} transaction
-   * @param {Array<Signer>} signers
-   * @param {ConfirmOptions} [options]
-   * @returns {Promise<TransactionSignature>}
+   * Retrieves the RPC API URL for the specified cluster
    */
-  export function sendAndConfirmTransaction(
-    connection: Connection,
-    transaction: Transaction,
-    signers: Array<Signer>,
-    options?: ConfirmOptions,
-  ): Promise<TransactionSignature>;
+  export function clusterApiUrl(cluster?: Cluster, tls?: boolean): string;
 
   /**
    * Send and confirm a raw transaction
@@ -3714,20 +3836,23 @@ declare module '@solana/web3.js' {
     options?: ConfirmOptions,
   ): Promise<TransactionSignature>;
 
-  export class TransactionExpiredBlockheightExceededError extends Error {
-    signature: string;
-    constructor(signature: string);
-  }
-  export class TransactionExpiredTimeoutError extends Error {
-    signature: string;
-    constructor(signature: string, timeoutSeconds: number);
-  }
-
-  export type Cluster = 'devnet' | 'testnet' | 'mainnet-beta';
   /**
-   * Retrieves the RPC API URL for the specified cluster
+   * Sign, send and confirm a transaction.
+   *
+   * If `commitment` option is not specified, defaults to 'max' commitment.
+   *
+   * @param {Connection} connection
+   * @param {Transaction} transaction
+   * @param {Array<Signer>} signers
+   * @param {ConfirmOptions} [options]
+   * @returns {Promise<TransactionSignature>}
    */
-  export function clusterApiUrl(cluster?: Cluster, tls?: boolean): string;
+  export function sendAndConfirmTransaction(
+    connection: Connection,
+    transaction: Transaction,
+    signers: Array<Signer>,
+    options?: ConfirmOptions,
+  ): Promise<TransactionSignature>;
 
   /**
    * There are 1-billion lamports in one SOL