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

package/src/connection.ts

@@ -1,8 +1,10 @@
+import Agent from 'agentkeepalive';
 import bs58 from 'bs58';
 import {Buffer} from 'buffer';
-import crossFetch from 'cross-fetch';
 // @ts-ignore
 import fastStableStringify from 'fast-stable-stringify';
+import type {Agent as HttpAgent} from 'http';
+import {Agent as HttpsAgent} from 'https';
 import {
   type as pick,
   number,
@@ -24,22 +26,32 @@ import {
 import type {Struct} from 'superstruct';
 import {Client as RpcWebSocketClient} from 'rpc-websockets';
 import RpcClient from 'jayson/lib/client/browser';
-import {IWSRequestParams} from 'rpc-websockets/dist/lib/client';
+import {JSONRPCError} from 'jayson';
 
-import {AgentManager} from './agent-manager';
 import {EpochSchedule} from './epoch-schedule';
-import {SendTransactionError} from './errors';
-import {NonceAccount} from './nonce-account';
+import {SendTransactionError, SolanaJSONRPCError} from './errors';
+import fetchImpl, {Response} from './fetch-impl';
+import {DurableNonce, NonceAccount} from './nonce-account';
 import {PublicKey} from './publickey';
 import {Signer} from './keypair';
 import {MS_PER_SLOT} from './timing';
-import {Transaction} from './transaction';
-import {Message} from './message';
-import assert from './util/assert';
-import {sleep} from './util/sleep';
-import {promiseTimeout} from './util/promise-timeout';
-import {toBuffer} from './util/to-buffer';
-import {makeWebsocketUrl} from './util/url';
+import {
+  Transaction,
+  TransactionStatus,
+  TransactionVersion,
+  VersionedTransaction,
+} from './transaction';
+import {Message, MessageHeader, MessageV0, VersionedMessage} from './message';
+import {AddressLookupTableAccount} from './programs/address-lookup-table/state';
+import assert from './utils/assert';
+import {sleep} from './utils/sleep';
+import {toBuffer} from './utils/to-buffer';
+import {
+  TransactionExpiredBlockheightExceededError,
+  TransactionExpiredNonceInvalidError,
+  TransactionExpiredTimeoutError,
+} from './transaction/expiry-custom-errors';
+import {makeWebsocketUrl} from './utils/makeWebsocketUrl';
 import type {Blockhash} from './blockhash';
 import type {FeeCalculator} from './fee-calculator';
 import type {TransactionSignature} from './transaction';
@@ -65,15 +77,32 @@ const BufferFromRawAccountData = coerce(
  */
 export const BLOCKHASH_CACHE_TIMEOUT_MS = 30 * 1000;
 
+/**
+ * HACK.
+ * Copied from rpc-websockets/dist/lib/client.
+ * Otherwise, `yarn build` fails with:
+ * https://gist.github.com/steveluscher/c057eca81d479ef705cdb53162f9971d
+ */
+interface IWSRequestParams {
+  [x: string]: any;
+  [x: number]: any;
+}
+
 type ClientSubscriptionId = number;
 /** @internal */ type ServerSubscriptionId = number;
 /** @internal */ type SubscriptionConfigHash = string;
 /** @internal */ type SubscriptionDisposeFn = () => Promise<void>;
+/** @internal */ type SubscriptionStateChangeCallback = (
+  nextState: StatefulSubscription['state'],
+) => void;
+/** @internal */ type SubscriptionStateChangeDisposeFn = () => void;
 /**
  * @internal
- * Every subscription has a list of callers interested in publishes.
+ * Every subscription contains the args used to open the subscription with
+ * the server, and a list of callers interested in notifications.
  */
 type BaseSubscription<TMethod = SubscriptionConfig['method']> = Readonly<{
+  args: IWSRequestParams;
   callbacks: Set<Extract<SubscriptionConfig, {method: TMethod}>['callback']>;
 }>;
 /**
@@ -114,62 +143,43 @@ type StatefulSubscription = Readonly<
     }
 >;
 /**
- * Different RPC subscription methods accept different params.
+ * A type that encapsulates a subscription's RPC method
+ * names and notification (callback) signature.
  */
 type SubscriptionConfig = Readonly<
   | {
       callback: AccountChangeCallback;
       method: 'accountSubscribe';
-      params: Readonly<{
-        commitment?: Commitment; // Must default to 'finalized'
-        publicKey: string; // PublicKey of the account as a base 58 string
-      }>;
       unsubscribeMethod: 'accountUnsubscribe';
     }
   | {
       callback: LogsCallback;
       method: 'logsSubscribe';
-      params: Readonly<{
-        commitment?: Commitment; // Must default to 'finalized'
-        filter: LogsFilter;
-      }>;
       unsubscribeMethod: 'logsUnsubscribe';
     }
   | {
       callback: ProgramAccountChangeCallback;
       method: 'programSubscribe';
-      params: Readonly<{
-        commitment?: Commitment; // Must default to 'finalized'
-        filters?: GetProgramAccountsFilter[];
-        programId: string; // PublicKey of the program as a base 58 string
-      }>;
       unsubscribeMethod: 'programUnsubscribe';
     }
   | {
       callback: RootChangeCallback;
       method: 'rootSubscribe';
-      params: undefined;
       unsubscribeMethod: 'rootUnsubscribe';
     }
   | {
       callback: SignatureSubscriptionCallback;
       method: 'signatureSubscribe';
-      params: Readonly<{
-        signature: TransactionSignature; // TransactionSignature as a base 58 string
-        options?: SignatureSubscriptionOptions;
-      }>;
       unsubscribeMethod: 'signatureUnsubscribe';
     }
   | {
       callback: SlotChangeCallback;
       method: 'slotSubscribe';
-      params: undefined;
       unsubscribeMethod: 'slotUnsubscribe';
     }
   | {
       callback: SlotUpdateCallback;
       method: 'slotsUpdatesSubscribe';
-      params: undefined;
       unsubscribeMethod: 'slotsUpdatesUnsubscribe';
     }
 >;
@@ -180,23 +190,24 @@ type SubscriptionConfig = Readonly<
 type DistributiveOmit<T, K extends PropertyKey> = T extends unknown
   ? Omit<T, K>
   : never;
-type Subscription = BaseSubscription &
-  StatefulSubscription &
-  DistributiveOmit<SubscriptionConfig, 'callback'>;
-
 /**
  * @internal
+ * This type represents a single subscribable 'topic.' It's made up of:
+ *
+ * - The args used to open the subscription with the server,
+ * - The state of the subscription, in terms of its connectedness, and
+ * - The set of callbacks to call when the server publishes notifications
+ *
+ * This record gets indexed by `SubscriptionConfigHash` and is used to
+ * set up subscriptions, fan out notifications, and track subscription state.
  */
-function hashSubscriptionConfig({
-  method,
-  params,
-}: SubscriptionConfig): SubscriptionConfigHash {
-  return fastStableStringify([method, params], true /* isArrayProp */);
-}
+type Subscription = BaseSubscription &
+  StatefulSubscription &
+  DistributiveOmit<SubscriptionConfig, 'callback'>;
 
-type RpcRequest = (methodName: string, args: Array<any>) => any;
+type RpcRequest = (methodName: string, args: Array<any>) => Promise<any>;
 
-type RpcBatchRequest = (requests: RpcParams[]) => any;
+type RpcBatchRequest = (requests: RpcParams[]) => Promise<any[]>;
 
 /**
  * @internal
@@ -231,6 +242,8 @@ export type SendOptions = {
   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;
 };
 
 /**
@@ -245,6 +258,8 @@ export type ConfirmOptions = {
   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;
 };
 
 /**
@@ -275,6 +290,8 @@ export type SignaturesForAddressOptions = {
   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;
 };
 
 /**
@@ -287,6 +304,74 @@ export type RpcResponseAndContext<T> = {
   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 =
+  BaseTransactionConfirmationStrategy & BlockhashWithExpiryBlockHeight;
+
+/**
+ * A strategy for confirming durable nonce transactions.
+ */
+export type DurableNonceTransactionConfirmationStrategy =
+  BaseTransactionConfirmationStrategy & {
+    /**
+     * The lowest slot at which to fetch the nonce value from the
+     * nonce account. This should be no lower than the slot at
+     * which the last-known value of the nonce was fetched.
+     */
+    minContextSlot: number;
+    /**
+     * The account where the current value of the nonce is stored.
+     */
+    nonceAccountPubkey: PublicKey;
+    /**
+     * The nonce value that was used to sign the transaction
+     * for which confirmation is being sought.
+     */
+    nonceValue: DurableNonce;
+  };
+
+/**
+ * Properties shared by all transaction confirmation strategies
+ */
+export type BaseTransactionConfirmationStrategy = Readonly<{
+  /** A signal that, when aborted, cancels any outstanding transaction confirmation operations */
+  abortSignal?: AbortSignal;
+  signature: TransactionSignature;
+}>;
+
+/* @internal */
+function assertEndpointUrl(putativeUrl: string) {
+  if (/^https?:/.test(putativeUrl) === false) {
+    throw new TypeError('Endpoint URL must start with `http:` or `https:`.');
+  }
+  return putativeUrl;
+}
+
+/** @internal */
+function extractCommitmentFromConfig<TConfig>(
+  commitmentOrConfig?: Commitment | ({commitment?: Commitment} & TConfig),
+) {
+  let commitment: Commitment | undefined;
+  let config: Omit<TConfig, 'commitment'> | undefined;
+  if (typeof commitmentOrConfig === 'string') {
+    commitment = commitmentOrConfig;
+  } else if (commitmentOrConfig) {
+    const {commitment: specifiedCommitment, ...specifiedConfig} =
+      commitmentOrConfig;
+    commitment = specifiedCommitment;
+    config = specifiedConfig;
+  }
+  return {commitment, config};
+}
+
 /**
  * @internal
  */
@@ -353,6 +438,32 @@ function notificationResultAndContext<T, U>(value: Struct<T, U>) {
   });
 }
 
+/**
+ * @internal
+ */
+function versionedMessageFromResponse(
+  version: TransactionVersion | undefined,
+  response: MessageResponse,
+): VersionedMessage {
+  if (version === 0) {
+    return new MessageV0({
+      header: response.header,
+      staticAccountKeys: response.accountKeys.map(
+        accountKey => new PublicKey(accountKey),
+      ),
+      recentBlockhash: response.recentBlockhash,
+      compiledInstructions: response.instructions.map(ix => ({
+        programIdIndex: ix.programIdIndex,
+        accountKeyIndexes: ix.accounts,
+        data: bs58.decode(ix.data),
+      })),
+      addressTableLookups: response.addressTableLookups!,
+    });
+  } else {
+    return new Message(response);
+  }
+}
+
 /**
  * The level of commitment desired when querying state
  * <pre>
@@ -389,6 +500,158 @@ export type Finality = 'confirmed' | 'finalized';
  */
 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;
+  /** Optional data slice to limit the returned account data */
+  dataSlice?: DataSlice;
+};
+
+/**
+ * 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;
+  /**
+   * Whether to populate the rewards array. If parameter not provided, the default includes rewards.
+   */
+  rewards?: boolean;
+  /**
+   * Level of transaction detail to return, either "full", "accounts", "signatures", or "none". If
+   * parameter not provided, the default detail level is "full". If "accounts" are requested,
+   * transaction details only include signatures and an annotated list of accounts in each
+   * transaction. Transaction metadata is limited to only: fee, err, pre_balances, post_balances,
+   * pre_token_balances, and post_token_balances.
+   */
+  transactionDetails?: 'accounts' | 'full' | 'none' | 'signatures';
+};
+
+/**
+ * Configuration object for changing `getBlock` query behavior
+ */
+export type GetVersionedBlockConfig = {
+  /** 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;
+  /**
+   * Whether to populate the rewards array. If parameter not provided, the default includes rewards.
+   */
+  rewards?: boolean;
+  /**
+   * Level of transaction detail to return, either "full", "accounts", "signatures", or "none". If
+   * parameter not provided, the default detail level is "full". If "accounts" are requested,
+   * transaction details only include signatures and an annotated list of accounts in each
+   * transaction. Transaction metadata is limited to only: fee, err, pre_balances, post_balances,
+   * pre_token_balances, and post_token_balances.
+   */
+  transactionDetails?: 'accounts' | 'full' | 'none' | 'signatures';
+};
+
+/**
+ * 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;
+};
+
+/**
+ * Configuration object for changing `getTransaction` query behavior
+ */
+export type GetVersionedTransactionConfig = {
+  /** 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
  */
@@ -596,13 +859,36 @@ export type SimulatedTransactionAccountInfo = {
   rentEpoch?: number;
 };
 
+export type TransactionReturnDataEncoding = 'base64';
+
+export type TransactionReturnData = {
+  programId: string;
+  data: [string, TransactionReturnDataEncoding];
+};
+
+export type SimulateTransactionConfig = {
+  /** Optional parameter used to enable signature verification before simulation */
+  sigVerify?: boolean;
+  /** Optional parameter used to replace the simulated transaction's recent blockhash with the latest blockhash */
+  replaceRecentBlockhash?: boolean;
+  /** Optional parameter used to set the commitment level when selecting the latest block */
+  commitment?: Commitment;
+  /** Optional parameter used to specify a list of account addresses to return post simulation state for */
+  accounts?: {
+    encoding: 'base64';
+    addresses: string[];
+  };
+  /** Optional parameter used to specify the minimum block slot that can be used for simulation */
+  minContextSlot?: number;
+};
+
 export type SimulatedTransactionResponse = {
   err: TransactionError | string | null;
   logs: Array<string> | null;
   accounts?: (SimulatedTransactionAccountInfo | null)[] | null;
   unitsConsumed?: number;
+  returnData?: TransactionReturnData | null;
 };
-
 const SimulatedTransactionResponseStruct = jsonRpcResultAndContext(
   pick({
     err: nullable(union([pick({}), string()])),
@@ -623,6 +909,14 @@ const SimulatedTransactionResponseStruct = jsonRpcResultAndContext(
       ),
     ),
     unitsConsumed: optional(number()),
+    returnData: optional(
+      nullable(
+        pick({
+          programId: string(),
+          data: tuple([string(), literal('base64')]),
+        }),
+      ),
+    ),
   }),
 );
 
@@ -645,6 +939,14 @@ export type TokenBalance = {
  */
 export type ParsedConfirmedTransactionMeta = ParsedTransactionMeta;
 
+/**
+ * Collection of addresses loaded by a transaction using address table lookups
+ */
+export type LoadedAddresses = {
+  writable: Array<PublicKey>;
+  readonly: Array<PublicKey>;
+};
+
 /**
  * Metadata for a parsed transaction on the ledger
  */
@@ -665,6 +967,10 @@ export type ParsedTransactionMeta = {
   postTokenBalances?: Array<TokenBalance> | null;
   /** The error result of transaction processing */
   err: TransactionError | null;
+  /** The collection of addresses loaded using address lookup tables */
+  loadedAddresses?: LoadedAddresses;
+  /** The compute units consumed after processing the transaction */
+  computeUnitsConsumed?: number;
 };
 
 export type CompiledInnerInstruction = {
@@ -692,6 +998,10 @@ export type ConfirmedTransactionMeta = {
   postTokenBalances?: Array<TokenBalance> | null;
   /** The error result of transaction processing */
   err: TransactionError | null;
+  /** The collection of addresses loaded using address lookup tables */
+  loadedAddresses?: LoadedAddresses;
+  /** The compute units consumed after processing the transaction */
+  computeUnitsConsumed?: number;
 };
 
 /**
@@ -713,8 +1023,42 @@ export type TransactionResponse = {
   blockTime?: number | null;
 };
 
+/**
+ * A processed transaction from the RPC API
+ */
+export type VersionedTransactionResponse = {
+  /** The slot during which the transaction was processed */
+  slot: number;
+  /** The transaction */
+  transaction: {
+    /** The transaction message */
+    message: VersionedMessage;
+    /** The transaction signatures */
+    signatures: string[];
+  };
+  /** Metadata produced from the transaction */
+  meta: ConfirmedTransactionMeta | null;
+  /** The unix timestamp of when the transaction was processed */
+  blockTime?: number | null;
+  /** The transaction version */
+  version?: TransactionVersion;
+};
+
+/**
+ * A processed transaction message from the RPC API
+ */
+type MessageResponse = {
+  accountKeys: string[];
+  header: MessageHeader;
+  instructions: CompiledInstruction[];
+  recentBlockhash: string;
+  addressTableLookups?: ParsedAddressTableLookup[];
+};
+
 /**
  * A confirmed transaction on the ledger
+ *
+ * @deprecated Deprecated since Solana v1.8.0.
  */
 export type ConfirmedTransaction = {
   /** The slot during which the transaction was processed */
@@ -749,6 +1093,8 @@ export type ParsedMessageAccount = {
   signer: boolean;
   /** Indicates if the account is writable for this transaction */
   writable: boolean;
+  /** Indicates if the account key came from the transaction or a lookup table */
+  source?: 'transaction' | 'lookupTable';
 };
 
 /**
@@ -763,6 +1109,18 @@ export type ParsedInstruction = {
   parsed: any;
 };
 
+/**
+ * A parsed address table lookup
+ */
+export type ParsedAddressTableLookup = {
+  /** Address lookup table account key */
+  accountKey: PublicKey;
+  /** Parsed instruction info */
+  writableIndexes: number[];
+  /** Parsed instruction info */
+  readonlyIndexes: number[];
+};
+
 /**
  * A parsed transaction message
  */
@@ -773,6 +1131,8 @@ export type ParsedMessage = {
   instructions: (ParsedInstruction | PartiallyDecodedInstruction)[];
   /** Recent blockhash */
   recentBlockhash: string;
+  /** Address table lookups used to load additional accounts */
+  addressTableLookups?: ParsedAddressTableLookup[] | null;
 };
 
 /**
@@ -804,6 +1164,8 @@ export type ParsedTransactionWithMeta = {
   meta: ParsedTransactionMeta | null;
   /** The unix timestamp of when the transaction was processed */
   blockTime?: number | null;
+  /** The version of the transaction message */
+  version?: TransactionVersion;
 };
 
 /**
@@ -827,6 +1189,8 @@ export type BlockResponse = {
     };
     /** Metadata produced from the transaction */
     meta: ConfirmedTransactionMeta | null;
+    /** The transaction version */
+    version?: TransactionVersion;
   }>;
   /** Vector of block rewards */
   rewards?: Array<{
@@ -844,86 +1208,227 @@ export type BlockResponse = {
 };
 
 /**
- * A ConfirmedBlock on the ledger
+ * A processed block fetched from the RPC API where the `transactionDetails` mode is `accounts`
  */
-export type ConfirmedBlock = {
+export type AccountsModeBlockResponse = VersionedAccountsModeBlockResponse;
+
+/**
+ * A processed block fetched from the RPC API where the `transactionDetails` mode is `none`
+ */
+export type NoneModeBlockResponse = VersionedNoneModeBlockResponse;
+
+/**
+ * A block with parsed transactions
+ */
+export type ParsedBlockResponse = {
   /** Blockhash of this block */
   blockhash: Blockhash;
   /** Blockhash of this block's parent */
   previousBlockhash: Blockhash;
   /** Slot index of this block's parent */
   parentSlot: number;
-  /** Vector of transactions and status metas */
+  /** Vector of transactions with status meta and original message */
   transactions: Array<{
-    transaction: Transaction;
-    meta: ConfirmedTransactionMeta | null;
+    /** The details of the transaction */
+    transaction: ParsedTransaction;
+    /** Metadata produced from the transaction */
+    meta: ParsedTransactionMeta | null;
+    /** The transaction version */
+    version?: TransactionVersion;
   }>;
   /** Vector of block rewards */
   rewards?: Array<{
+    /** Public key of reward recipient */
     pubkey: string;
+    /** Reward value in lamports */
     lamports: number;
+    /** Account balance after reward is applied */
     postBalance: number | null;
+    /** Type of reward received */
     rewardType: string | null;
   }>;
   /** The unix timestamp of when the block was processed */
   blockTime: number | null;
+  /** The number of blocks beneath this block */
+  blockHeight: number | null;
 };
 
 /**
- * A Block on the ledger with signatures only
+ * A block with parsed transactions where the `transactionDetails` mode is `accounts`
  */
-export type BlockSignatures = {
+export type ParsedAccountsModeBlockResponse = Omit<
+  ParsedBlockResponse,
+  'transactions'
+> & {
+  transactions: Array<
+    Omit<ParsedBlockResponse['transactions'][number], 'transaction'> & {
+      transaction: Pick<
+        ParsedBlockResponse['transactions'][number]['transaction'],
+        'signatures'
+      > & {
+        accountKeys: ParsedMessageAccount[];
+      };
+    }
+  >;
+};
+
+/**
+ * A block with parsed transactions where the `transactionDetails` mode is `none`
+ */
+export type ParsedNoneModeBlockResponse = Omit<
+  ParsedBlockResponse,
+  'transactions'
+>;
+
+/**
+ * A processed block fetched from the RPC API
+ */
+export type VersionedBlockResponse = {
   /** Blockhash of this block */
   blockhash: Blockhash;
   /** Blockhash of this block's parent */
   previousBlockhash: Blockhash;
   /** Slot index of this block's parent */
   parentSlot: number;
-  /** Vector of signatures */
-  signatures: Array<string>;
+  /** Vector of transactions with status meta and original message */
+  transactions: Array<{
+    /** The transaction */
+    transaction: {
+      /** The transaction message */
+      message: VersionedMessage;
+      /** The transaction signatures */
+      signatures: string[];
+    };
+    /** Metadata produced from the transaction */
+    meta: ConfirmedTransactionMeta | null;
+    /** The transaction version */
+    version?: TransactionVersion;
+  }>;
+  /** Vector of block rewards */
+  rewards?: Array<{
+    /** Public key of reward recipient */
+    pubkey: string;
+    /** Reward value in lamports */
+    lamports: number;
+    /** Account balance after reward is applied */
+    postBalance: number | null;
+    /** Type of reward received */
+    rewardType: string | null;
+  }>;
   /** The unix timestamp of when the block was processed */
   blockTime: number | null;
 };
 
 /**
- * recent block production information
+ * A processed block fetched from the RPC API where the `transactionDetails` mode is `accounts`
  */
-export type BlockProduction = Readonly<{
-  /** a dictionary of validator identities, as base-58 encoded strings. Value is a two element array containing the number of leader slots and the number of blocks produced */
-  byIdentity: Readonly<Record<string, ReadonlyArray<number>>>;
-  /** Block production slot range */
-  range: Readonly<{
-    /** first slot of the block production information (inclusive) */
-    firstSlot: number;
-    /** last slot of block production information (inclusive) */
-    lastSlot: number;
-  }>;
-}>;
-
-export type GetBlockProductionConfig = {
-  /** Optional commitment level */
-  commitment?: Commitment;
-  /** Slot range to return block production for. If parameter not provided, defaults to current epoch. */
-  range?: {
-    /** first slot to return block production information for (inclusive) */
-    firstSlot: number;
-    /** last slot to return block production information for (inclusive). If parameter not provided, defaults to the highest slot */
-    lastSlot?: number;
-  };
-  /** Only return results for this validator identity (base-58 encoded) */
-  identity?: string;
+export type VersionedAccountsModeBlockResponse = Omit<
+  VersionedBlockResponse,
+  'transactions'
+> & {
+  transactions: Array<
+    Omit<VersionedBlockResponse['transactions'][number], 'transaction'> & {
+      transaction: Pick<
+        VersionedBlockResponse['transactions'][number]['transaction'],
+        'signatures'
+      > & {
+        accountKeys: ParsedMessageAccount[];
+      };
+    }
+  >;
 };
 
 /**
- * Expected JSON RPC response for the "getBlockProduction" message
+ * A processed block fetched from the RPC API where the `transactionDetails` mode is `none`
  */
-const BlockProductionResponseStruct = jsonRpcResultAndContext(
-  pick({
-    byIdentity: record(string(), array(number())),
-    range: pick({
-      firstSlot: number(),
-      lastSlot: number(),
-    }),
+export type VersionedNoneModeBlockResponse = Omit<
+  VersionedBlockResponse,
+  'transactions'
+>;
+
+/**
+ * A confirmed block on the ledger
+ *
+ * @deprecated Deprecated since Solana v1.8.0.
+ */
+export type ConfirmedBlock = {
+  /** Blockhash of this block */
+  blockhash: Blockhash;
+  /** Blockhash of this block's parent */
+  previousBlockhash: Blockhash;
+  /** Slot index of this block's parent */
+  parentSlot: number;
+  /** Vector of transactions and status metas */
+  transactions: Array<{
+    transaction: Transaction;
+    meta: ConfirmedTransactionMeta | null;
+  }>;
+  /** Vector of block rewards */
+  rewards?: Array<{
+    pubkey: string;
+    lamports: number;
+    postBalance: number | null;
+    rewardType: string | null;
+  }>;
+  /** The unix timestamp of when the block was processed */
+  blockTime: number | null;
+};
+
+/**
+ * A Block on the ledger with signatures only
+ */
+export type BlockSignatures = {
+  /** Blockhash of this block */
+  blockhash: Blockhash;
+  /** Blockhash of this block's parent */
+  previousBlockhash: Blockhash;
+  /** Slot index of this block's parent */
+  parentSlot: number;
+  /** Vector of signatures */
+  signatures: Array<string>;
+  /** The unix timestamp of when the block was processed */
+  blockTime: number | null;
+};
+
+/**
+ * recent block production information
+ */
+export type BlockProduction = Readonly<{
+  /** a dictionary of validator identities, as base-58 encoded strings. Value is a two element array containing the number of leader slots and the number of blocks produced */
+  byIdentity: Readonly<Record<string, ReadonlyArray<number>>>;
+  /** Block production slot range */
+  range: Readonly<{
+    /** first slot of the block production information (inclusive) */
+    firstSlot: number;
+    /** last slot of block production information (inclusive) */
+    lastSlot: number;
+  }>;
+}>;
+
+export type GetBlockProductionConfig = {
+  /** Optional commitment level */
+  commitment?: Commitment;
+  /** Slot range to return block production for. If parameter not provided, defaults to current epoch. */
+  range?: {
+    /** first slot to return block production information for (inclusive) */
+    firstSlot: number;
+    /** last slot to return block production information for (inclusive). If parameter not provided, defaults to the highest slot */
+    lastSlot?: number;
+  };
+  /** Only return results for this validator identity (base-58 encoded) */
+  identity?: string;
+};
+
+/**
+ * Expected JSON RPC response for the "getBlockProduction" message
+ */
+const BlockProductionResponseStruct = jsonRpcResultAndContext(
+  pick({
+    byIdentity: record(string(), array(number())),
+    range: pick({
+      firstSlot: number(),
+      lastSlot: number(),
+    }),
   }),
 );
 
@@ -943,29 +1448,64 @@ export type PerfSample = {
 
 function createRpcClient(
   url: string,
-  useHttps: boolean,
   httpHeaders?: HttpHeaders,
-  customFetch?: typeof crossFetch,
+  customFetch?: FetchFn,
   fetchMiddleware?: FetchMiddleware,
   disableRetryOnRateLimit?: boolean,
+  httpAgent?: HttpAgent | HttpsAgent | false,
 ): RpcClient {
-  const fetch = customFetch ? customFetch : crossFetch;
-  let agentManager: AgentManager | undefined;
-  if (!process.env.BROWSER) {
-    agentManager = new AgentManager(useHttps);
+  const fetch = customFetch ? customFetch : fetchImpl;
+  let agent: HttpAgent | HttpsAgent | undefined;
+  if (process.env.BROWSER) {
+    if (httpAgent != null) {
+      console.warn(
+        'You have supplied an `httpAgent` when creating a `Connection` in a browser environment.' +
+          'It has been ignored; `httpAgent` is only used in Node environments.',
+      );
+    }
+  } else {
+    if (httpAgent == null) {
+      if (process.env.NODE_ENV !== 'test') {
+        agent = new Agent({
+          // One second fewer than the Solana RPC's keepalive timeout.
+          // Read more: https://github.com/solana-labs/solana/issues/27859#issuecomment-1340097889
+          freeSocketTimeout: 19000,
+          keepAlive: true,
+          maxSockets: 25,
+        });
+      }
+    } else {
+      if (httpAgent !== false) {
+        const isHttps = url.startsWith('https:');
+        if (isHttps && !(httpAgent instanceof HttpsAgent)) {
+          throw new Error(
+            'The endpoint `' +
+              url +
+              '` can only be paired with an `https.Agent`. You have, instead, supplied an ' +
+              '`http.Agent` through `httpAgent`.',
+          );
+        } else if (!isHttps && httpAgent instanceof HttpsAgent) {
+          throw new Error(
+            'The endpoint `' +
+              url +
+              '` can only be paired with an `http.Agent`. You have, instead, supplied an ' +
+              '`https.Agent` through `httpAgent`.',
+          );
+        }
+        agent = httpAgent;
+      }
+    }
   }
 
-  let fetchWithMiddleware:
-    | ((url: string, options: any) => Promise<Response>)
-    | undefined;
+  let fetchWithMiddleware: FetchFn | undefined;
 
   if (fetchMiddleware) {
-    fetchWithMiddleware = async (url: string, options: any) => {
-      const modifiedFetchArgs = await new Promise<[string, any]>(
+    fetchWithMiddleware = async (info, init) => {
+      const modifiedFetchArgs = await new Promise<Parameters<FetchFn>>(
         (resolve, reject) => {
           try {
-            fetchMiddleware(url, options, (modifiedUrl, modifiedOptions) =>
-              resolve([modifiedUrl, modifiedOptions]),
+            fetchMiddleware(info, init, (modifiedInfo, modifiedInit) =>
+              resolve([modifiedInfo, modifiedInit]),
             );
           } catch (error) {
             reject(error);
@@ -977,7 +1517,6 @@ function createRpcClient(
   }
 
   const clientBrowser = new RpcClient(async (request, callback) => {
-    const agent = agentManager ? agentManager.requestStart() : undefined;
     const options = {
       method: 'POST',
       body: request,
@@ -987,6 +1526,7 @@ function createRpcClient(
           'Content-Type': 'application/json',
         },
         httpHeaders || {},
+        COMMON_HTTP_HEADERS,
       ),
     };
 
@@ -1026,8 +1566,6 @@ function createRpcClient(
       }
     } catch (err) {
       if (err instanceof Error) callback(err);
-    } finally {
-      agentManager && agentManager.requestEnd();
     }
   }, {});
 
@@ -1549,6 +2087,12 @@ const GetSignatureStatusesRpcResult = jsonRpcResultAndContext(
  */
 const GetMinimumBalanceForRentExemptionRpcResult = jsonRpcResult(number());
 
+const AddressTableLookupStruct = pick({
+  accountKey: PublicKeyFromString,
+  writableIndexes: array(number()),
+  readonlyIndexes: array(number()),
+});
+
 const ConfirmedTransactionResult = pick({
   signatures: array(string()),
   message: pick({
@@ -1566,9 +2110,22 @@ const ConfirmedTransactionResult = pick({
       }),
     ),
     recentBlockhash: string(),
+    addressTableLookups: optional(array(AddressTableLookupStruct)),
   }),
 });
 
+const AnnotatedAccountKey = pick({
+  pubkey: PublicKeyFromString,
+  signer: boolean(),
+  writable: boolean(),
+  source: optional(union([literal('transaction'), literal('lookupTable')])),
+});
+
+const ConfirmedTransactionAccountsModeResult = pick({
+  accountKeys: array(AnnotatedAccountKey),
+  signatures: array(string()),
+});
+
 const ParsedInstructionResult = pick({
   parsed: unknown(),
   program: string(),
@@ -1617,15 +2174,10 @@ const ParsedOrRawInstruction = coerce(
 const ParsedConfirmedTransactionResult = pick({
   signatures: array(string()),
   message: pick({
-    accountKeys: array(
-      pick({
-        pubkey: PublicKeyFromString,
-        signer: boolean(),
-        writable: boolean(),
-      }),
-    ),
+    accountKeys: array(AnnotatedAccountKey),
     instructions: array(ParsedOrRawInstruction),
     recentBlockhash: string(),
+    addressTableLookups: optional(nullable(array(AddressTableLookupStruct))),
   }),
 });
 
@@ -1636,6 +2188,11 @@ const TokenBalanceResult = pick({
   uiTokenAmount: TokenAmountResult,
 });
 
+const LoadedAddressesResult = pick({
+  writable: array(PublicKeyFromString),
+  readonly: array(PublicKeyFromString),
+});
+
 /**
  * @internal
  */
@@ -1663,6 +2220,8 @@ const ConfirmedTransactionMetaResult = pick({
   logMessages: optional(nullable(array(string()))),
   preTokenBalances: optional(nullable(array(TokenBalanceResult))),
   postTokenBalances: optional(nullable(array(TokenBalanceResult))),
+  loadedAddresses: optional(LoadedAddressesResult),
+  computeUnitsConsumed: optional(number()),
 });
 
 /**
@@ -1686,6 +2245,18 @@ const ParsedConfirmedTransactionMetaResult = pick({
   logMessages: optional(nullable(array(string()))),
   preTokenBalances: optional(nullable(array(TokenBalanceResult))),
   postTokenBalances: optional(nullable(array(TokenBalanceResult))),
+  loadedAddresses: optional(LoadedAddressesResult),
+  computeUnitsConsumed: optional(number()),
+});
+
+const TransactionVersionStruct = union([literal(0), literal('legacy')]);
+
+/** @internal */
+const RewardsResult = pick({
+  pubkey: string(),
+  lamports: number(),
+  postBalance: nullable(number()),
+  rewardType: nullable(string()),
 });
 
 /**
@@ -1701,18 +2272,111 @@ const GetBlockRpcResult = jsonRpcResult(
         pick({
           transaction: ConfirmedTransactionResult,
           meta: nullable(ConfirmedTransactionMetaResult),
+          version: optional(TransactionVersionStruct),
         }),
       ),
-      rewards: optional(
-        array(
-          pick({
-            pubkey: string(),
-            lamports: number(),
-            postBalance: nullable(number()),
-            rewardType: nullable(string()),
-          }),
-        ),
+      rewards: optional(array(RewardsResult)),
+      blockTime: nullable(number()),
+      blockHeight: nullable(number()),
+    }),
+  ),
+);
+
+/**
+ * Expected JSON RPC response for the "getBlock" message when `transactionDetails` is `none`
+ */
+const GetNoneModeBlockRpcResult = jsonRpcResult(
+  nullable(
+    pick({
+      blockhash: string(),
+      previousBlockhash: string(),
+      parentSlot: number(),
+      rewards: optional(array(RewardsResult)),
+      blockTime: nullable(number()),
+      blockHeight: nullable(number()),
+    }),
+  ),
+);
+
+/**
+ * Expected JSON RPC response for the "getBlock" message when `transactionDetails` is `accounts`
+ */
+const GetAccountsModeBlockRpcResult = jsonRpcResult(
+  nullable(
+    pick({
+      blockhash: string(),
+      previousBlockhash: string(),
+      parentSlot: number(),
+      transactions: array(
+        pick({
+          transaction: ConfirmedTransactionAccountsModeResult,
+          meta: nullable(ConfirmedTransactionMetaResult),
+          version: optional(TransactionVersionStruct),
+        }),
+      ),
+      rewards: optional(array(RewardsResult)),
+      blockTime: nullable(number()),
+      blockHeight: nullable(number()),
+    }),
+  ),
+);
+
+/**
+ * Expected parsed JSON RPC response for the "getBlock" message
+ */
+const GetParsedBlockRpcResult = jsonRpcResult(
+  nullable(
+    pick({
+      blockhash: string(),
+      previousBlockhash: string(),
+      parentSlot: number(),
+      transactions: array(
+        pick({
+          transaction: ParsedConfirmedTransactionResult,
+          meta: nullable(ParsedConfirmedTransactionMetaResult),
+          version: optional(TransactionVersionStruct),
+        }),
+      ),
+      rewards: optional(array(RewardsResult)),
+      blockTime: nullable(number()),
+      blockHeight: nullable(number()),
+    }),
+  ),
+);
+
+/**
+ * Expected parsed JSON RPC response for the "getBlock" message  when `transactionDetails` is `accounts`
+ */
+const GetParsedAccountsModeBlockRpcResult = jsonRpcResult(
+  nullable(
+    pick({
+      blockhash: string(),
+      previousBlockhash: string(),
+      parentSlot: number(),
+      transactions: array(
+        pick({
+          transaction: ConfirmedTransactionAccountsModeResult,
+          meta: nullable(ParsedConfirmedTransactionMetaResult),
+          version: optional(TransactionVersionStruct),
+        }),
       ),
+      rewards: optional(array(RewardsResult)),
+      blockTime: nullable(number()),
+      blockHeight: nullable(number()),
+    }),
+  ),
+);
+
+/**
+ * Expected parsed JSON RPC response for the "getBlock" message  when `transactionDetails` is `none`
+ */
+const GetParsedNoneModeBlockRpcResult = jsonRpcResult(
+  nullable(
+    pick({
+      blockhash: string(),
+      previousBlockhash: string(),
+      parentSlot: number(),
+      rewards: optional(array(RewardsResult)),
       blockTime: nullable(number()),
       blockHeight: nullable(number()),
     }),
@@ -1736,16 +2400,7 @@ const GetConfirmedBlockRpcResult = jsonRpcResult(
           meta: nullable(ConfirmedTransactionMetaResult),
         }),
       ),
-      rewards: optional(
-        array(
-          pick({
-            pubkey: string(),
-            lamports: number(),
-            postBalance: nullable(number()),
-            rewardType: nullable(string()),
-          }),
-        ),
-      ),
+      rewards: optional(array(RewardsResult)),
       blockTime: nullable(number()),
     }),
   ),
@@ -1776,6 +2431,7 @@ const GetTransactionRpcResult = jsonRpcResult(
       meta: ConfirmedTransactionMetaResult,
       blockTime: optional(nullable(number())),
       transaction: ConfirmedTransactionResult,
+      version: optional(TransactionVersionStruct),
     }),
   ),
 );
@@ -1790,6 +2446,7 @@ const GetParsedTransactionRpcResult = jsonRpcResult(
       transaction: ParsedConfirmedTransactionResult,
       meta: nullable(ParsedConfirmedTransactionMetaResult),
       blockTime: optional(nullable(number())),
+      version: optional(TransactionVersionStruct),
     }),
   ),
 );
@@ -1940,6 +2597,8 @@ export type GetProgramAccountsConfig = {
   dataSlice?: DataSlice;
   /** Optional array of filters to apply to accounts */
   filters?: GetProgramAccountsFilter[];
+  /** The minimum slot that the request can be evaluated at */
+  minContextSlot?: number;
 };
 
 /**
@@ -1950,6 +2609,8 @@ export type GetParsedProgramAccountsConfig = {
   commitment?: Commitment;
   /** Optional array of filters to apply to accounts */
   filters?: GetProgramAccountsFilter[];
+  /** The minimum slot that the request can be evaluated at */
+  minContextSlot?: number;
 };
 
 /**
@@ -1958,8 +2619,62 @@ export type GetParsedProgramAccountsConfig = {
 export type GetMultipleAccountsConfig = {
   /** Optional commitment level */
   commitment?: Commitment;
-  /** Optional encoding for account data (default base64) */
-  encoding?: 'base64' | 'jsonParsed';
+  /** The minimum slot that the request can be evaluated at */
+  minContextSlot?: number;
+  /** Optional data slice to limit the returned account data */
+  dataSlice?: DataSlice;
+};
+
+/**
+ * Configuration object for `getStakeActivation`
+ */
+export type GetStakeActivationConfig = {
+  /** Optional commitment level */
+  commitment?: Commitment;
+  /** Epoch for which to calculate activation details. If parameter not provided, defaults to current epoch */
+  epoch?: number;
+  /** The minimum slot that the request can be evaluated at */
+  minContextSlot?: number;
+};
+
+/**
+ * Configuration object for `getStakeActivation`
+ */
+export type GetTokenAccountsByOwnerConfig = {
+  /** Optional commitment level */
+  commitment?: Commitment;
+  /** The minimum slot that the request can be evaluated at */
+  minContextSlot?: number;
+};
+
+/**
+ * Configuration object for `getStakeActivation`
+ */
+export type GetTransactionCountConfig = {
+  /** Optional commitment level */
+  commitment?: Commitment;
+  /** The minimum slot that the request can be evaluated at */
+  minContextSlot?: number;
+};
+
+/**
+ * Configuration object for `getNonce`
+ */
+export type GetNonceConfig = {
+  /** Optional commitment level */
+  commitment?: Commitment;
+  /** The minimum slot that the request can be evaluated at */
+  minContextSlot?: number;
+};
+
+/**
+ * Configuration object for `getNonceAndContext`
+ */
+export type GetNonceAndContextConfig = {
+  /** Optional commitment level */
+  commitment?: Commitment;
+  /** The minimum slot that the request can be evaluated at */
+  minContextSlot?: number;
 };
 
 /**
@@ -2047,7 +2762,7 @@ export type SignatureSubscriptionCallback = (
  * Signature subscription options
  */
 export type SignatureSubscriptionOptions = {
-  commitment?: Commitment; // Must default to 'finalized'
+  commitment?: Commitment;
   enableReceivedNotification?: boolean;
 };
 
@@ -2145,26 +2860,44 @@ export type ConfirmedSignatureInfo = {
   memo: string | null;
   /** The unix timestamp of when the transaction was processed */
   blockTime?: number | null;
+  /** Cluster confirmation status, if available. Possible values: `processed`, `confirmed`, `finalized` */
+  confirmationStatus?: TransactionConfirmationStatus;
 };
 
 /**
  * An object defining headers to be passed to the RPC server
  */
-export type HttpHeaders = {[header: string]: string};
+export type HttpHeaders = {
+  [header: string]: string;
+} & {
+  // Prohibited headers; for internal use only.
+  'solana-client'?: never;
+};
+
+/**
+ * The type of the JavaScript `fetch()` API
+ */
+export type FetchFn = typeof fetchImpl;
 
 /**
  * A callback used to augment the outgoing HTTP request
  */
 export type FetchMiddleware = (
-  url: string,
-  options: any,
-  fetch: (modifiedUrl: string, modifiedOptions: any) => void,
+  info: Parameters<FetchFn>[0],
+  init: Parameters<FetchFn>[1],
+  fetch: (...a: Parameters<FetchFn>) => void,
 ) => void;
 
 /**
  * Configuration for instantiating a Connection
  */
 export type ConnectionConfig = {
+  /**
+   * An `http.Agent` that will be used to manage socket connections (eg. to implement connection
+   * persistence). Set this to `false` to create a connection that uses no agent. This applies to
+   * Node environments only.
+   */
+  httpAgent?: HttpAgent | HttpsAgent | false;
   /** Optional commitment level */
   commitment?: Commitment;
   /** Optional endpoint URL to the fullnode JSON RPC PubSub WebSocket Endpoint */
@@ -2172,7 +2905,7 @@ export type ConnectionConfig = {
   /** Optional HTTP headers object */
   httpHeaders?: HttpHeaders;
   /** Optional custom fetch function */
-  fetch?: typeof crossFetch;
+  fetch?: FetchFn;
   /** Optional fetch middleware callback */
   fetchMiddleware?: FetchMiddleware;
   /** Optional Disable retrying calls when server responds with HTTP 429 (Too Many Requests) */
@@ -2181,6 +2914,11 @@ export type ConnectionConfig = {
   confirmTransactionInitialTimeout?: number;
 };
 
+/** @internal */
+const COMMON_HTTP_HEADERS = {
+  'solana-client': `js/${process.env.npm_package_version ?? 'UNKNOWN'}`,
+};
+
 /**
  * A connection to a fullnode JSON RPC endpoint
  */
@@ -2200,33 +2938,50 @@ export class Connection {
   /** @internal */ _rpcWebSocketIdleTimeout: ReturnType<
     typeof setTimeout
   > | null = null;
+  /** @internal
+   * A number that we increment every time an active connection closes.
+   * Used to determine whether the same socket connection that was open
+   * when an async operation started is the same one that's active when
+   * its continuation fires.
+   *
+   */ private _rpcWebSocketGeneration: number = 0;
 
   /** @internal */ _disableBlockhashCaching: boolean = false;
   /** @internal */ _pollingBlockhash: boolean = false;
   /** @internal */ _blockhashInfo: {
-    recentBlockhash: Blockhash | null;
+    latestBlockhash: BlockhashWithExpiryBlockHeight | null;
     lastFetch: number;
     simulatedSignatures: Array<string>;
     transactionSignatures: Array<string>;
   } = {
-    recentBlockhash: null,
+    latestBlockhash: null,
     lastFetch: 0,
     transactionSignatures: [],
     simulatedSignatures: [],
   };
 
-  /** @internal */ _nextClientSubscriptionId: ClientSubscriptionId = 0;
-  /** @internal */ _subscriptionDisposeFunctionsByClientSubscriptionId: {
+  /** @internal */ private _nextClientSubscriptionId: ClientSubscriptionId = 0;
+  /** @internal */ private _subscriptionDisposeFunctionsByClientSubscriptionId: {
     [clientSubscriptionId: ClientSubscriptionId]:
       | SubscriptionDisposeFn
       | undefined;
   } = {};
-  /** @internal */ _subscriptionCallbacksByServerSubscriptionId: {
+  /** @internal */ private _subscriptionHashByClientSubscriptionId: {
+    [clientSubscriptionId: ClientSubscriptionId]:
+      | SubscriptionConfigHash
+      | undefined;
+  } = {};
+  /** @internal */ private _subscriptionStateChangeCallbacksByHash: {
+    [hash: SubscriptionConfigHash]:
+      | Set<SubscriptionStateChangeCallback>
+      | undefined;
+  } = {};
+  /** @internal */ private _subscriptionCallbacksByServerSubscriptionId: {
     [serverSubscriptionId: ServerSubscriptionId]:
       | Set<SubscriptionConfig['callback']>
       | undefined;
   } = {};
-  /** @internal */ _subscriptionsByHash: {
+  /** @internal */ private _subscriptionsByHash: {
     [hash: SubscriptionConfigHash]: Subscription | undefined;
   } = {};
   /**
@@ -2242,7 +2997,7 @@ export class Connection {
    * NOTE: There is a proposal to eliminate this special case, here:
    * https://github.com/solana-labs/solana/issues/18892
    */
-  /** @internal */ _subscriptionsAutoDisposedByRpc: Set<ServerSubscriptionId> =
+  /** @internal */ private _subscriptionsAutoDisposedByRpc: Set<ServerSubscriptionId> =
     new Set();
 
   /**
@@ -2255,14 +3010,12 @@ export class Connection {
     endpoint: string,
     commitmentOrConfig?: Commitment | ConnectionConfig,
   ) {
-    let url = new URL(endpoint);
-    const useHttps = url.protocol === 'https:';
-
     let wsEndpoint;
     let httpHeaders;
     let fetch;
     let fetchMiddleware;
     let disableRetryOnRateLimit;
+    let httpAgent;
     if (commitmentOrConfig && typeof commitmentOrConfig === 'string') {
       this._commitment = commitmentOrConfig;
     } else if (commitmentOrConfig) {
@@ -2274,18 +3027,19 @@ export class Connection {
       fetch = commitmentOrConfig.fetch;
       fetchMiddleware = commitmentOrConfig.fetchMiddleware;
       disableRetryOnRateLimit = commitmentOrConfig.disableRetryOnRateLimit;
+      httpAgent = commitmentOrConfig.httpAgent;
     }
 
-    this._rpcEndpoint = endpoint;
+    this._rpcEndpoint = assertEndpointUrl(endpoint);
     this._rpcWsEndpoint = wsEndpoint || makeWebsocketUrl(endpoint);
 
     this._rpcClient = createRpcClient(
-      url.toString(),
-      useHttps,
+      endpoint,
       httpHeaders,
       fetch,
       fetchMiddleware,
       disableRetryOnRateLimit,
+      httpAgent,
     );
     this._rpcRequest = createRpcRequest(this._rpcClient);
     this._rpcBatchRequest = createRpcBatchRequest(this._rpcClient);
@@ -2346,17 +3100,23 @@ export class Connection {
    */
   async getBalanceAndContext(
     publicKey: PublicKey,
-    commitment?: Commitment,
+    commitmentOrConfig?: Commitment | GetBalanceConfig,
   ): Promise<RpcResponseAndContext<number>> {
-    const args = this._buildArgs([publicKey.toBase58()], commitment);
+    /** @internal */
+    const {commitment, config} =
+      extractCommitmentFromConfig(commitmentOrConfig);
+    const args = this._buildArgs(
+      [publicKey.toBase58()],
+      commitment,
+      undefined /* encoding */,
+      config,
+    );
     const unsafeRes = await this._rpcRequest('getBalance', args);
     const res = create(unsafeRes, jsonRpcResultAndContext(number()));
     if ('error' in res) {
-      throw new Error(
-        'failed to get balance for ' +
-          publicKey.toBase58() +
-          ': ' +
-          res.error.message,
+      throw new SolanaJSONRPCError(
+        res.error,
+        `failed to get balance for ${publicKey.toBase58()}`,
       );
     }
     return res.result;
@@ -2367,9 +3127,9 @@ export class Connection {
    */
   async getBalance(
     publicKey: PublicKey,
-    commitment?: Commitment,
+    commitmentOrConfig?: Commitment | GetBalanceConfig,
   ): Promise<number> {
-    return await this.getBalanceAndContext(publicKey, commitment)
+    return await this.getBalanceAndContext(publicKey, commitmentOrConfig)
       .then(x => x.value)
       .catch(e => {
         throw new Error(
@@ -2385,8 +3145,9 @@ export class Connection {
     const unsafeRes = await this._rpcRequest('getBlockTime', [slot]);
     const res = create(unsafeRes, jsonRpcResult(nullable(number())));
     if ('error' in res) {
-      throw new Error(
-        'failed to get block time for slot ' + slot + ': ' + res.error.message,
+      throw new SolanaJSONRPCError(
+        res.error,
+        `failed to get block time for slot ${slot}`,
       );
     }
     return res.result;
@@ -2400,8 +3161,9 @@ export class Connection {
     const unsafeRes = await this._rpcRequest('minimumLedgerSlot', []);
     const res = create(unsafeRes, jsonRpcResult(number()));
     if ('error' in res) {
-      throw new Error(
-        'failed to get minimum ledger slot: ' + res.error.message,
+      throw new SolanaJSONRPCError(
+        res.error,
+        'failed to get minimum ledger slot',
       );
     }
     return res.result;
@@ -2414,8 +3176,9 @@ export class Connection {
     const unsafeRes = await this._rpcRequest('getFirstAvailableBlock', []);
     const res = create(unsafeRes, SlotRpcResult);
     if ('error' in res) {
-      throw new Error(
-        'failed to get first available block: ' + res.error.message,
+      throw new SolanaJSONRPCError(
+        res.error,
+        'failed to get first available block',
       );
     }
     return res.result;
@@ -2444,7 +3207,7 @@ export class Connection {
     const unsafeRes = await this._rpcRequest('getSupply', [configArg]);
     const res = create(unsafeRes, GetSupplyRpcResult);
     if ('error' in res) {
-      throw new Error('failed to get supply: ' + res.error.message);
+      throw new SolanaJSONRPCError(res.error, 'failed to get supply');
     }
     return res.result;
   }
@@ -2460,7 +3223,7 @@ export class Connection {
     const unsafeRes = await this._rpcRequest('getTokenSupply', args);
     const res = create(unsafeRes, jsonRpcResultAndContext(TokenAmountResult));
     if ('error' in res) {
-      throw new Error('failed to get token supply: ' + res.error.message);
+      throw new SolanaJSONRPCError(res.error, 'failed to get token supply');
     }
     return res.result;
   }
@@ -2476,8 +3239,9 @@ export class Connection {
     const unsafeRes = await this._rpcRequest('getTokenAccountBalance', args);
     const res = create(unsafeRes, jsonRpcResultAndContext(TokenAmountResult));
     if ('error' in res) {
-      throw new Error(
-        'failed to get token account balance: ' + res.error.message,
+      throw new SolanaJSONRPCError(
+        res.error,
+        'failed to get token account balance',
       );
     }
     return res.result;
@@ -2491,12 +3255,14 @@ export class Connection {
   async getTokenAccountsByOwner(
     ownerAddress: PublicKey,
     filter: TokenAccountsFilter,
-    commitment?: Commitment,
+    commitmentOrConfig?: Commitment | GetTokenAccountsByOwnerConfig,
   ): Promise<
     RpcResponseAndContext<
       Array<{pubkey: PublicKey; account: AccountInfo<Buffer>}>
     >
   > {
+    const {commitment, config} =
+      extractCommitmentFromConfig(commitmentOrConfig);
     let _args: any[] = [ownerAddress.toBase58()];
     if ('mint' in filter) {
       _args.push({mint: filter.mint.toBase58()});
@@ -2504,15 +3270,13 @@ export class Connection {
       _args.push({programId: filter.programId.toBase58()});
     }
 
-    const args = this._buildArgs(_args, commitment, 'base64');
+    const args = this._buildArgs(_args, commitment, 'base64', config);
     const unsafeRes = await this._rpcRequest('getTokenAccountsByOwner', args);
     const res = create(unsafeRes, GetTokenAccountsByOwner);
     if ('error' in res) {
-      throw new Error(
-        'failed to get token accounts owned by account ' +
-          ownerAddress.toBase58() +
-          ': ' +
-          res.error.message,
+      throw new SolanaJSONRPCError(
+        res.error,
+        `failed to get token accounts owned by account ${ownerAddress.toBase58()}`,
       );
     }
     return res.result;
@@ -2543,11 +3307,9 @@ export class Connection {
     const unsafeRes = await this._rpcRequest('getTokenAccountsByOwner', args);
     const res = create(unsafeRes, GetParsedTokenAccountsByOwner);
     if ('error' in res) {
-      throw new Error(
-        'failed to get token accounts owned by account ' +
-          ownerAddress.toBase58() +
-          ': ' +
-          res.error.message,
+      throw new SolanaJSONRPCError(
+        res.error,
+        `failed to get token accounts owned by account ${ownerAddress.toBase58()}`,
       );
     }
     return res.result;
@@ -2567,7 +3329,7 @@ export class Connection {
     const unsafeRes = await this._rpcRequest('getLargestAccounts', args);
     const res = create(unsafeRes, GetLargestAccountsRpcResult);
     if ('error' in res) {
-      throw new Error('failed to get largest accounts: ' + res.error.message);
+      throw new SolanaJSONRPCError(res.error, 'failed to get largest accounts');
     }
     return res.result;
   }
@@ -2584,8 +3346,9 @@ export class Connection {
     const unsafeRes = await this._rpcRequest('getTokenLargestAccounts', args);
     const res = create(unsafeRes, GetTokenLargestAccountsResult);
     if ('error' in res) {
-      throw new Error(
-        'failed to get token largest accounts: ' + res.error.message,
+      throw new SolanaJSONRPCError(
+        res.error,
+        'failed to get token largest accounts',
       );
     }
     return res.result;
@@ -2596,20 +3359,25 @@ export class Connection {
    */
   async getAccountInfoAndContext(
     publicKey: PublicKey,
-    commitment?: Commitment,
+    commitmentOrConfig?: Commitment | GetAccountInfoConfig,
   ): Promise<RpcResponseAndContext<AccountInfo<Buffer> | null>> {
-    const args = this._buildArgs([publicKey.toBase58()], commitment, 'base64');
+    const {commitment, config} =
+      extractCommitmentFromConfig(commitmentOrConfig);
+    const args = this._buildArgs(
+      [publicKey.toBase58()],
+      commitment,
+      'base64',
+      config,
+    );
     const unsafeRes = await this._rpcRequest('getAccountInfo', args);
     const res = create(
       unsafeRes,
       jsonRpcResultAndContext(nullable(AccountInfoResult)),
     );
     if ('error' in res) {
-      throw new Error(
-        'failed to get info about account ' +
-          publicKey.toBase58() +
-          ': ' +
-          res.error.message,
+      throw new SolanaJSONRPCError(
+        res.error,
+        `failed to get info about account ${publicKey.toBase58()}`,
       );
     }
     return res.result;
@@ -2620,14 +3388,17 @@ export class Connection {
    */
   async getParsedAccountInfo(
     publicKey: PublicKey,
-    commitment?: Commitment,
+    commitmentOrConfig?: Commitment | GetAccountInfoConfig,
   ): Promise<
     RpcResponseAndContext<AccountInfo<Buffer | ParsedAccountData> | null>
   > {
+    const {commitment, config} =
+      extractCommitmentFromConfig(commitmentOrConfig);
     const args = this._buildArgs(
       [publicKey.toBase58()],
       commitment,
       'jsonParsed',
+      config,
     );
     const unsafeRes = await this._rpcRequest('getAccountInfo', args);
     const res = create(
@@ -2635,11 +3406,9 @@ export class Connection {
       jsonRpcResultAndContext(nullable(ParsedAccountInfoResult)),
     );
     if ('error' in res) {
-      throw new Error(
-        'failed to get info about account ' +
-          publicKey.toBase58() +
-          ': ' +
-          res.error.message,
+      throw new SolanaJSONRPCError(
+        res.error,
+        `failed to get info about account ${publicKey.toBase58()}`,
       );
     }
     return res.result;
@@ -2650,10 +3419,13 @@ export class Connection {
    */
   async getAccountInfo(
     publicKey: PublicKey,
-    commitment?: Commitment,
+    commitmentOrConfig?: Commitment | GetAccountInfoConfig,
   ): Promise<AccountInfo<Buffer> | null> {
     try {
-      const res = await this.getAccountInfoAndContext(publicKey, commitment);
+      const res = await this.getAccountInfoAndContext(
+        publicKey,
+        commitmentOrConfig,
+      );
       return res.value;
     } catch (e) {
       throw new Error(
@@ -2662,23 +3434,52 @@ export class Connection {
     }
   }
 
+  /**
+   * Fetch all the account info for multiple accounts specified by an array of public keys, return with context
+   */
+  async getMultipleParsedAccounts(
+    publicKeys: PublicKey[],
+    rawConfig?: GetMultipleAccountsConfig,
+  ): Promise<
+    RpcResponseAndContext<(AccountInfo<Buffer | ParsedAccountData> | null)[]>
+  > {
+    const {commitment, config} = extractCommitmentFromConfig(rawConfig);
+    const keys = publicKeys.map(key => key.toBase58());
+    const args = this._buildArgs([keys], commitment, 'jsonParsed', config);
+    const unsafeRes = await this._rpcRequest('getMultipleAccounts', args);
+    const res = create(
+      unsafeRes,
+      jsonRpcResultAndContext(array(nullable(ParsedAccountInfoResult))),
+    );
+    if ('error' in res) {
+      throw new SolanaJSONRPCError(
+        res.error,
+        `failed to get info for accounts ${keys}`,
+      );
+    }
+    return res.result;
+  }
+
   /**
    * Fetch all the account info for multiple accounts specified by an array of public keys, return with context
    */
   async getMultipleAccountsInfoAndContext(
     publicKeys: PublicKey[],
-    commitment?: Commitment,
+    commitmentOrConfig?: Commitment | GetMultipleAccountsConfig,
   ): Promise<RpcResponseAndContext<(AccountInfo<Buffer> | null)[]>> {
+    const {commitment, config} =
+      extractCommitmentFromConfig(commitmentOrConfig);
     const keys = publicKeys.map(key => key.toBase58());
-    const args = this._buildArgs([keys], commitment, 'base64');
+    const args = this._buildArgs([keys], commitment, 'base64', config);
     const unsafeRes = await this._rpcRequest('getMultipleAccounts', args);
     const res = create(
       unsafeRes,
       jsonRpcResultAndContext(array(nullable(AccountInfoResult))),
     );
     if ('error' in res) {
-      throw new Error(
-        'failed to get info for accounts ' + keys + ': ' + res.error.message,
+      throw new SolanaJSONRPCError(
+        res.error,
+        `failed to get info for accounts ${keys}`,
       );
     }
     return res.result;
@@ -2689,11 +3490,11 @@ export class Connection {
    */
   async getMultipleAccountsInfo(
     publicKeys: PublicKey[],
-    commitment?: Commitment,
+    commitmentOrConfig?: Commitment | GetMultipleAccountsConfig,
   ): Promise<(AccountInfo<Buffer> | null)[]> {
     const res = await this.getMultipleAccountsInfoAndContext(
       publicKeys,
-      commitment,
+      commitmentOrConfig,
     );
     return res.value;
   }
@@ -2703,23 +3504,27 @@ export class Connection {
    */
   async getStakeActivation(
     publicKey: PublicKey,
-    commitment?: Commitment,
+    commitmentOrConfig?: Commitment | GetStakeActivationConfig,
     epoch?: number,
   ): Promise<StakeActivationData> {
+    const {commitment, config} =
+      extractCommitmentFromConfig(commitmentOrConfig);
     const args = this._buildArgs(
       [publicKey.toBase58()],
       commitment,
-      undefined,
-      epoch !== undefined ? {epoch} : undefined,
+      undefined /* encoding */,
+      {
+        ...config,
+        epoch: epoch != null ? epoch : config?.epoch,
+      },
     );
 
     const unsafeRes = await this._rpcRequest('getStakeActivation', args);
     const res = create(unsafeRes, jsonRpcResult(StakeActivationResult));
     if ('error' in res) {
-      throw new Error(
-        `failed to get Stake Activation ${publicKey.toBase58()}: ${
-          res.error.message
-        }`,
+      throw new SolanaJSONRPCError(
+        res.error,
+        `failed to get Stake Activation ${publicKey.toBase58()}`,
       );
     }
     return res.result;
@@ -2734,40 +3539,21 @@ export class Connection {
     programId: PublicKey,
     configOrCommitment?: GetProgramAccountsConfig | Commitment,
   ): Promise<Array<{pubkey: PublicKey; account: AccountInfo<Buffer>}>> {
-    const extra: Pick<GetProgramAccountsConfig, 'dataSlice' | 'filters'> = {};
-
-    let commitment;
-    let encoding;
-    if (configOrCommitment) {
-      if (typeof configOrCommitment === 'string') {
-        commitment = configOrCommitment;
-      } else {
-        commitment = configOrCommitment.commitment;
-        encoding = configOrCommitment.encoding;
-
-        if (configOrCommitment.dataSlice) {
-          extra.dataSlice = configOrCommitment.dataSlice;
-        }
-        if (configOrCommitment.filters) {
-          extra.filters = configOrCommitment.filters;
-        }
-      }
-    }
-
+    const {commitment, config} =
+      extractCommitmentFromConfig(configOrCommitment);
+    const {encoding, ...configWithoutEncoding} = config || {};
     const args = this._buildArgs(
       [programId.toBase58()],
       commitment,
       encoding || 'base64',
-      extra,
+      configWithoutEncoding,
     );
     const unsafeRes = await this._rpcRequest('getProgramAccounts', args);
     const res = create(unsafeRes, jsonRpcResult(array(KeyedAccountInfoResult)));
     if ('error' in res) {
-      throw new Error(
-        'failed to get accounts owned by program ' +
-          programId.toBase58() +
-          ': ' +
-          res.error.message,
+      throw new SolanaJSONRPCError(
+        res.error,
+        `failed to get accounts owned by program ${programId.toBase58()}`,
       );
     }
     return res.result;
@@ -2787,26 +3573,13 @@ export class Connection {
       account: AccountInfo<Buffer | ParsedAccountData>;
     }>
   > {
-    const extra: Pick<GetParsedProgramAccountsConfig, 'filters'> = {};
-
-    let commitment;
-    if (configOrCommitment) {
-      if (typeof configOrCommitment === 'string') {
-        commitment = configOrCommitment;
-      } else {
-        commitment = configOrCommitment.commitment;
-
-        if (configOrCommitment.filters) {
-          extra.filters = configOrCommitment.filters;
-        }
-      }
-    }
-
+    const {commitment, config} =
+      extractCommitmentFromConfig(configOrCommitment);
     const args = this._buildArgs(
       [programId.toBase58()],
       commitment,
       'jsonParsed',
-      extra,
+      config,
     );
     const unsafeRes = await this._rpcRequest('getProgramAccounts', args);
     const res = create(
@@ -2814,90 +3587,460 @@ export class Connection {
       jsonRpcResult(array(KeyedParsedAccountInfoResult)),
     );
     if ('error' in res) {
-      throw new Error(
-        'failed to get accounts owned by program ' +
-          programId.toBase58() +
-          ': ' +
-          res.error.message,
+      throw new SolanaJSONRPCError(
+        res.error,
+        `failed to get accounts owned by program ${programId.toBase58()}`,
       );
     }
     return res.result;
   }
 
-  /**
-   * Confirm the transaction identified by the specified signature.
-   */
+  confirmTransaction(
+    strategy:
+      | BlockheightBasedTransactionConfirmationStrategy
+      | DurableNonceTransactionConfirmationStrategy,
+    commitment?: Commitment,
+  ): Promise<RpcResponseAndContext<SignatureResult>>;
+
+  /** @deprecated Instead, call `confirmTransaction` using a `TransactionConfirmationConfig` */
+  // eslint-disable-next-line no-dupe-class-members
+  confirmTransaction(
+    strategy: TransactionSignature,
+    commitment?: Commitment,
+  ): Promise<RpcResponseAndContext<SignatureResult>>;
+
+  // eslint-disable-next-line no-dupe-class-members
   async confirmTransaction(
-    signature: TransactionSignature,
+    strategy:
+      | BlockheightBasedTransactionConfirmationStrategy
+      | DurableNonceTransactionConfirmationStrategy
+      | TransactionSignature,
     commitment?: Commitment,
   ): Promise<RpcResponseAndContext<SignatureResult>> {
+    let rawSignature: string;
+
+    if (typeof strategy == 'string') {
+      rawSignature = strategy;
+    } else {
+      const config = strategy as
+        | BlockheightBasedTransactionConfirmationStrategy
+        | DurableNonceTransactionConfirmationStrategy;
+      if (config.abortSignal?.aborted) {
+        return Promise.reject(config.abortSignal.reason);
+      }
+      rawSignature = config.signature;
+    }
+
     let decodedSignature;
+
     try {
-      decodedSignature = bs58.decode(signature);
+      decodedSignature = bs58.decode(rawSignature);
     } catch (err) {
-      throw new Error('signature must be base58 encoded: ' + signature);
+      throw new Error('signature must be base58 encoded: ' + rawSignature);
     }
 
     assert(decodedSignature.length === 64, 'signature has invalid length');
 
-    const start = Date.now();
-    const subscriptionCommitment = commitment || this.commitment;
+    if (typeof strategy === 'string') {
+      return await this.confirmTransactionUsingLegacyTimeoutStrategy({
+        commitment: commitment || this.commitment,
+        signature: rawSignature,
+      });
+    } else if ('lastValidBlockHeight' in strategy) {
+      return await this.confirmTransactionUsingBlockHeightExceedanceStrategy({
+        commitment: commitment || this.commitment,
+        strategy,
+      });
+    } else {
+      return await this.confirmTransactionUsingDurableNonceStrategy({
+        commitment: commitment || this.commitment,
+        strategy,
+      });
+    }
+  }
+
+  private getCancellationPromise(signal?: AbortSignal): Promise<never> {
+    return new Promise<never>((_, reject) => {
+      if (signal == null) {
+        return;
+      }
+      if (signal.aborted) {
+        reject(signal.reason);
+      } else {
+        signal.addEventListener('abort', () => {
+          reject(signal.reason);
+        });
+      }
+    });
+  }
 
-    let subscriptionId;
-    let response: RpcResponseAndContext<SignatureResult> | null = null;
-    const confirmPromise = new Promise((resolve, reject) => {
+  private getTransactionConfirmationPromise({
+    commitment,
+    signature,
+  }: {
+    commitment?: Commitment;
+    signature: string;
+  }): {
+    abortConfirmation(): void;
+    confirmationPromise: Promise<{
+      __type: TransactionStatus.PROCESSED;
+      response: RpcResponseAndContext<SignatureResult>;
+    }>;
+  } {
+    let signatureSubscriptionId: number | undefined;
+    let disposeSignatureSubscriptionStateChangeObserver:
+      | SubscriptionStateChangeDisposeFn
+      | undefined;
+    let done = false;
+    const confirmationPromise = new Promise<{
+      __type: TransactionStatus.PROCESSED;
+      response: RpcResponseAndContext<SignatureResult>;
+    }>((resolve, reject) => {
       try {
-        subscriptionId = this.onSignature(
+        signatureSubscriptionId = this.onSignature(
           signature,
           (result: SignatureResult, context: Context) => {
-            subscriptionId = undefined;
-            response = {
+            signatureSubscriptionId = undefined;
+            const response = {
               context,
               value: result,
             };
-            resolve(null);
+            resolve({__type: TransactionStatus.PROCESSED, response});
+          },
+          commitment,
+        );
+        const subscriptionSetupPromise = new Promise<void>(
+          resolveSubscriptionSetup => {
+            if (signatureSubscriptionId == null) {
+              resolveSubscriptionSetup();
+            } else {
+              disposeSignatureSubscriptionStateChangeObserver =
+                this._onSubscriptionStateChange(
+                  signatureSubscriptionId,
+                  nextState => {
+                    if (nextState === 'subscribed') {
+                      resolveSubscriptionSetup();
+                    }
+                  },
+                );
+            }
           },
-          subscriptionCommitment,
         );
+        (async () => {
+          await subscriptionSetupPromise;
+          if (done) return;
+          const response = await this.getSignatureStatus(signature);
+          if (done) return;
+          if (response == null) {
+            return;
+          }
+          const {context, value} = response;
+          if (value == null) {
+            return;
+          }
+          if (value?.err) {
+            reject(value.err);
+          } else {
+            switch (commitment) {
+              case 'confirmed':
+              case 'single':
+              case 'singleGossip': {
+                if (value.confirmationStatus === 'processed') {
+                  return;
+                }
+                break;
+              }
+              case 'finalized':
+              case 'max':
+              case 'root': {
+                if (
+                  value.confirmationStatus === 'processed' ||
+                  value.confirmationStatus === 'confirmed'
+                ) {
+                  return;
+                }
+                break;
+              }
+              // exhaust enums to ensure full coverage
+              case 'processed':
+              case 'recent':
+            }
+            done = true;
+            resolve({
+              __type: TransactionStatus.PROCESSED,
+              response: {
+                context,
+                value,
+              },
+            });
+          }
+        })();
       } catch (err) {
         reject(err);
       }
     });
+    const abortConfirmation = () => {
+      if (disposeSignatureSubscriptionStateChangeObserver) {
+        disposeSignatureSubscriptionStateChangeObserver();
+        disposeSignatureSubscriptionStateChangeObserver = undefined;
+      }
+      if (signatureSubscriptionId != null) {
+        this.removeSignatureListener(signatureSubscriptionId);
+        signatureSubscriptionId = undefined;
+      }
+    };
+    return {abortConfirmation, confirmationPromise};
+  }
 
-    let timeoutMs = this._confirmTransactionInitialTimeout || 60 * 1000;
-    switch (subscriptionCommitment) {
-      case 'processed':
-      case 'recent':
-      case 'single':
-      case 'confirmed':
-      case 'singleGossip': {
-        timeoutMs = this._confirmTransactionInitialTimeout || 30 * 1000;
-        break;
+  private async confirmTransactionUsingBlockHeightExceedanceStrategy({
+    commitment,
+    strategy: {abortSignal, lastValidBlockHeight, signature},
+  }: {
+    commitment?: Commitment;
+    strategy: BlockheightBasedTransactionConfirmationStrategy;
+  }) {
+    let done: boolean = false;
+    const expiryPromise = new Promise<{
+      __type: TransactionStatus.BLOCKHEIGHT_EXCEEDED;
+    }>(resolve => {
+      const checkBlockHeight = async () => {
+        try {
+          const blockHeight = await this.getBlockHeight(commitment);
+          return blockHeight;
+        } catch (_e) {
+          return -1;
+        }
+      };
+      (async () => {
+        let currentBlockHeight = await checkBlockHeight();
+        if (done) return;
+        while (currentBlockHeight <= lastValidBlockHeight) {
+          await sleep(1000);
+          if (done) return;
+          currentBlockHeight = await checkBlockHeight();
+          if (done) return;
+        }
+        resolve({__type: TransactionStatus.BLOCKHEIGHT_EXCEEDED});
+      })();
+    });
+    const {abortConfirmation, confirmationPromise} =
+      this.getTransactionConfirmationPromise({commitment, signature});
+    const cancellationPromise = this.getCancellationPromise(abortSignal);
+    let result: RpcResponseAndContext<SignatureResult>;
+    try {
+      const outcome = await Promise.race([
+        cancellationPromise,
+        confirmationPromise,
+        expiryPromise,
+      ]);
+      if (outcome.__type === TransactionStatus.PROCESSED) {
+        result = outcome.response;
+      } else {
+        throw new TransactionExpiredBlockheightExceededError(signature);
       }
-      // exhaust enums to ensure full coverage
-      case 'finalized':
-      case 'max':
-      case 'root':
+    } finally {
+      done = true;
+      abortConfirmation();
     }
+    return result;
+  }
 
+  private async confirmTransactionUsingDurableNonceStrategy({
+    commitment,
+    strategy: {
+      abortSignal,
+      minContextSlot,
+      nonceAccountPubkey,
+      nonceValue,
+      signature,
+    },
+  }: {
+    commitment?: Commitment;
+    strategy: DurableNonceTransactionConfirmationStrategy;
+  }) {
+    let done: boolean = false;
+    const expiryPromise = new Promise<{
+      __type: TransactionStatus.NONCE_INVALID;
+      slotInWhichNonceDidAdvance: number | null;
+    }>(resolve => {
+      let currentNonceValue: string | undefined = nonceValue;
+      let lastCheckedSlot: number | null = null;
+      const getCurrentNonceValue = async () => {
+        try {
+          const {context, value: nonceAccount} = await this.getNonceAndContext(
+            nonceAccountPubkey,
+            {
+              commitment,
+              minContextSlot,
+            },
+          );
+          lastCheckedSlot = context.slot;
+          return nonceAccount?.nonce;
+        } catch (e) {
+          // If for whatever reason we can't reach/read the nonce
+          // account, just keep using the last-known value.
+          return currentNonceValue;
+        }
+      };
+      (async () => {
+        currentNonceValue = await getCurrentNonceValue();
+        if (done) return;
+        while (
+          true // eslint-disable-line no-constant-condition
+        ) {
+          if (nonceValue !== currentNonceValue) {
+            resolve({
+              __type: TransactionStatus.NONCE_INVALID,
+              slotInWhichNonceDidAdvance: lastCheckedSlot,
+            });
+            return;
+          }
+          await sleep(2000);
+          if (done) return;
+          currentNonceValue = await getCurrentNonceValue();
+          if (done) return;
+        }
+      })();
+    });
+    const {abortConfirmation, confirmationPromise} =
+      this.getTransactionConfirmationPromise({commitment, signature});
+    const cancellationPromise = this.getCancellationPromise(abortSignal);
+    let result: RpcResponseAndContext<SignatureResult>;
     try {
-      await promiseTimeout(confirmPromise, timeoutMs);
-    } finally {
-      if (subscriptionId) {
-        this.removeSignatureListener(subscriptionId);
+      const outcome = await Promise.race([
+        cancellationPromise,
+        confirmationPromise,
+        expiryPromise,
+      ]);
+      if (outcome.__type === TransactionStatus.PROCESSED) {
+        result = outcome.response;
+      } else {
+        // Double check that the transaction is indeed unconfirmed.
+        let signatureStatus:
+          | RpcResponseAndContext<SignatureStatus | null>
+          | null
+          | undefined;
+        while (
+          true // eslint-disable-line no-constant-condition
+        ) {
+          const status = await this.getSignatureStatus(signature);
+          if (status == null) {
+            break;
+          }
+          if (
+            status.context.slot <
+            (outcome.slotInWhichNonceDidAdvance ?? minContextSlot)
+          ) {
+            await sleep(400);
+            continue;
+          }
+          signatureStatus = status;
+          break;
+        }
+        if (signatureStatus?.value) {
+          const commitmentForStatus = commitment || 'finalized';
+          const {confirmationStatus} = signatureStatus.value;
+          switch (commitmentForStatus) {
+            case 'processed':
+            case 'recent':
+              if (
+                confirmationStatus !== 'processed' &&
+                confirmationStatus !== 'confirmed' &&
+                confirmationStatus !== 'finalized'
+              ) {
+                throw new TransactionExpiredNonceInvalidError(signature);
+              }
+              break;
+            case 'confirmed':
+            case 'single':
+            case 'singleGossip':
+              if (
+                confirmationStatus !== 'confirmed' &&
+                confirmationStatus !== 'finalized'
+              ) {
+                throw new TransactionExpiredNonceInvalidError(signature);
+              }
+              break;
+            case 'finalized':
+            case 'max':
+            case 'root':
+              if (confirmationStatus !== 'finalized') {
+                throw new TransactionExpiredNonceInvalidError(signature);
+              }
+              break;
+            default:
+              // Exhaustive switch.
+              // eslint-disable-next-line @typescript-eslint/no-unused-vars
+              ((_: never) => {})(commitmentForStatus);
+          }
+          result = {
+            context: signatureStatus.context,
+            value: {err: signatureStatus.value.err},
+          };
+        } else {
+          throw new TransactionExpiredNonceInvalidError(signature);
+        }
       }
+    } finally {
+      done = true;
+      abortConfirmation();
     }
+    return result;
+  }
 
-    if (response === null) {
-      const duration = (Date.now() - start) / 1000;
-      throw new Error(
-        `Transaction was not confirmed in ${duration.toFixed(
-          2,
-        )} seconds. It is unknown if it succeeded or failed. Check signature ${signature} using the Solana Explorer or CLI tools.`,
+  private async confirmTransactionUsingLegacyTimeoutStrategy({
+    commitment,
+    signature,
+  }: {
+    commitment?: Commitment;
+    signature: string;
+  }) {
+    let timeoutId;
+    const expiryPromise = new Promise<{
+      __type: TransactionStatus.TIMED_OUT;
+      timeoutMs: number;
+    }>(resolve => {
+      let timeoutMs = this._confirmTransactionInitialTimeout || 60 * 1000;
+      switch (commitment) {
+        case 'processed':
+        case 'recent':
+        case 'single':
+        case 'confirmed':
+        case 'singleGossip': {
+          timeoutMs = this._confirmTransactionInitialTimeout || 30 * 1000;
+          break;
+        }
+        // exhaust enums to ensure full coverage
+        case 'finalized':
+        case 'max':
+        case 'root':
+      }
+      timeoutId = setTimeout(
+        () => resolve({__type: TransactionStatus.TIMED_OUT, timeoutMs}),
+        timeoutMs,
       );
+    });
+    const {abortConfirmation, confirmationPromise} =
+      this.getTransactionConfirmationPromise({
+        commitment,
+        signature,
+      });
+    let result: RpcResponseAndContext<SignatureResult>;
+    try {
+      const outcome = await Promise.race([confirmationPromise, expiryPromise]);
+      if (outcome.__type === TransactionStatus.PROCESSED) {
+        result = outcome.response;
+      } else {
+        throw new TransactionExpiredTimeoutError(
+          signature,
+          outcome.timeoutMs / 1000,
+        );
+      }
+    } finally {
+      clearTimeout(timeoutId);
+      abortConfirmation();
     }
-
-    return response;
+    return result;
   }
 
   /**
@@ -2907,7 +4050,7 @@ export class Connection {
     const unsafeRes = await this._rpcRequest('getClusterNodes', []);
     const res = create(unsafeRes, jsonRpcResult(array(ContactInfoResult)));
     if ('error' in res) {
-      throw new Error('failed to get cluster nodes: ' + res.error.message);
+      throw new SolanaJSONRPCError(res.error, 'failed to get cluster nodes');
     }
     return res.result;
   }
@@ -2920,7 +4063,7 @@ export class Connection {
     const unsafeRes = await this._rpcRequest('getVoteAccounts', args);
     const res = create(unsafeRes, GetVoteAccounts);
     if ('error' in res) {
-      throw new Error('failed to get vote accounts: ' + res.error.message);
+      throw new SolanaJSONRPCError(res.error, 'failed to get vote accounts');
     }
     return res.result;
   }
@@ -2928,12 +4071,21 @@ export class Connection {
   /**
    * Fetch the current slot that the node is processing
    */
-  async getSlot(commitment?: Commitment): Promise<number> {
-    const args = this._buildArgs([], commitment);
+  async getSlot(
+    commitmentOrConfig?: Commitment | GetSlotConfig,
+  ): Promise<number> {
+    const {commitment, config} =
+      extractCommitmentFromConfig(commitmentOrConfig);
+    const args = this._buildArgs(
+      [],
+      commitment,
+      undefined /* encoding */,
+      config,
+    );
     const unsafeRes = await this._rpcRequest('getSlot', args);
     const res = create(unsafeRes, jsonRpcResult(number()));
     if ('error' in res) {
-      throw new Error('failed to get slot: ' + res.error.message);
+      throw new SolanaJSONRPCError(res.error, 'failed to get slot');
     }
     return res.result;
   }
@@ -2941,12 +4093,21 @@ export class Connection {
   /**
    * Fetch the current slot leader of the cluster
    */
-  async getSlotLeader(commitment?: Commitment): Promise<string> {
-    const args = this._buildArgs([], commitment);
+  async getSlotLeader(
+    commitmentOrConfig?: Commitment | GetSlotLeaderConfig,
+  ): Promise<string> {
+    const {commitment, config} =
+      extractCommitmentFromConfig(commitmentOrConfig);
+    const args = this._buildArgs(
+      [],
+      commitment,
+      undefined /* encoding */,
+      config,
+    );
     const unsafeRes = await this._rpcRequest('getSlotLeader', args);
     const res = create(unsafeRes, jsonRpcResult(string()));
     if ('error' in res) {
-      throw new Error('failed to get slot leader: ' + res.error.message);
+      throw new SolanaJSONRPCError(res.error, 'failed to get slot leader');
     }
     return res.result;
   }
@@ -2965,7 +4126,7 @@ export class Connection {
     const unsafeRes = await this._rpcRequest('getSlotLeaders', args);
     const res = create(unsafeRes, jsonRpcResult(array(PublicKeyFromString)));
     if ('error' in res) {
-      throw new Error('failed to get slot leaders: ' + res.error.message);
+      throw new SolanaJSONRPCError(res.error, 'failed to get slot leaders');
     }
     return res.result;
   }
@@ -3000,7 +4161,7 @@ export class Connection {
     const unsafeRes = await this._rpcRequest('getSignatureStatuses', params);
     const res = create(unsafeRes, GetSignatureStatusesRpcResult);
     if ('error' in res) {
-      throw new Error('failed to get signature status: ' + res.error.message);
+      throw new SolanaJSONRPCError(res.error, 'failed to get signature status');
     }
     return res.result;
   }
@@ -3008,12 +4169,24 @@ export class Connection {
   /**
    * Fetch the current transaction count of the cluster
    */
-  async getTransactionCount(commitment?: Commitment): Promise<number> {
-    const args = this._buildArgs([], commitment);
+  async getTransactionCount(
+    commitmentOrConfig?: Commitment | GetTransactionCountConfig,
+  ): Promise<number> {
+    const {commitment, config} =
+      extractCommitmentFromConfig(commitmentOrConfig);
+    const args = this._buildArgs(
+      [],
+      commitment,
+      undefined /* encoding */,
+      config,
+    );
     const unsafeRes = await this._rpcRequest('getTransactionCount', args);
     const res = create(unsafeRes, jsonRpcResult(number()));
     if ('error' in res) {
-      throw new Error('failed to get transaction count: ' + res.error.message);
+      throw new SolanaJSONRPCError(
+        res.error,
+        'failed to get transaction count',
+      );
     }
     return res.result;
   }
@@ -3041,7 +4214,7 @@ export class Connection {
     const unsafeRes = await this._rpcRequest('getInflationGovernor', args);
     const res = create(unsafeRes, GetInflationGovernorRpcResult);
     if ('error' in res) {
-      throw new Error('failed to get inflation: ' + res.error.message);
+      throw new SolanaJSONRPCError(res.error, 'failed to get inflation');
     }
     return res.result;
   }
@@ -3052,20 +4225,23 @@ export class Connection {
   async getInflationReward(
     addresses: PublicKey[],
     epoch?: number,
-    commitment?: Commitment,
+    commitmentOrConfig?: Commitment | GetInflationRewardConfig,
   ): Promise<(InflationReward | null)[]> {
+    const {commitment, config} =
+      extractCommitmentFromConfig(commitmentOrConfig);
     const args = this._buildArgs(
       [addresses.map(pubkey => pubkey.toBase58())],
       commitment,
-      undefined,
+      undefined /* encoding */,
       {
-        epoch,
+        ...config,
+        epoch: epoch != null ? epoch : config?.epoch,
       },
     );
     const unsafeRes = await this._rpcRequest('getInflationReward', args);
     const res = create(unsafeRes, GetInflationRewardResult);
     if ('error' in res) {
-      throw new Error('failed to get inflation reward: ' + res.error.message);
+      throw new SolanaJSONRPCError(res.error, 'failed to get inflation reward');
     }
     return res.result;
   }
@@ -3073,12 +4249,21 @@ export class Connection {
   /**
    * Fetch the Epoch Info parameters
    */
-  async getEpochInfo(commitment?: Commitment): Promise<EpochInfo> {
-    const args = this._buildArgs([], commitment);
+  async getEpochInfo(
+    commitmentOrConfig?: Commitment | GetEpochInfoConfig,
+  ): Promise<EpochInfo> {
+    const {commitment, config} =
+      extractCommitmentFromConfig(commitmentOrConfig);
+    const args = this._buildArgs(
+      [],
+      commitment,
+      undefined /* encoding */,
+      config,
+    );
     const unsafeRes = await this._rpcRequest('getEpochInfo', args);
     const res = create(unsafeRes, GetEpochInfoRpcResult);
     if ('error' in res) {
-      throw new Error('failed to get epoch info: ' + res.error.message);
+      throw new SolanaJSONRPCError(res.error, 'failed to get epoch info');
     }
     return res.result;
   }
@@ -3090,7 +4275,7 @@ export class Connection {
     const unsafeRes = await this._rpcRequest('getEpochSchedule', []);
     const res = create(unsafeRes, GetEpochScheduleRpcResult);
     if ('error' in res) {
-      throw new Error('failed to get epoch schedule: ' + res.error.message);
+      throw new SolanaJSONRPCError(res.error, 'failed to get epoch schedule');
     }
     const epochSchedule = res.result;
     return new EpochSchedule(
@@ -3110,7 +4295,7 @@ export class Connection {
     const unsafeRes = await this._rpcRequest('getLeaderSchedule', []);
     const res = create(unsafeRes, GetLeaderScheduleRpcResult);
     if ('error' in res) {
-      throw new Error('failed to get leader schedule: ' + res.error.message);
+      throw new SolanaJSONRPCError(res.error, 'failed to get leader schedule');
     }
     return res.result;
   }
@@ -3151,7 +4336,7 @@ export class Connection {
     const unsafeRes = await this._rpcRequest('getRecentBlockhash', args);
     const res = create(unsafeRes, GetRecentBlockhashAndContextRpcResult);
     if ('error' in res) {
-      throw new Error('failed to get recent blockhash: ' + res.error.message);
+      throw new SolanaJSONRPCError(res.error, 'failed to get recent blockhash');
     }
     return res.result;
   }
@@ -3163,15 +4348,15 @@ export class Connection {
   async getRecentPerformanceSamples(
     limit?: number,
   ): Promise<Array<PerfSample>> {
-    const args = this._buildArgs(limit ? [limit] : []);
     const unsafeRes = await this._rpcRequest(
       'getRecentPerformanceSamples',
-      args,
+      limit ? [limit] : [],
     );
     const res = create(unsafeRes, GetRecentPerformanceSamplesRpcResult);
     if ('error' in res) {
-      throw new Error(
-        'failed to get recent performance samples: ' + res.error.message,
+      throw new SolanaJSONRPCError(
+        res.error,
+        'failed to get recent performance samples',
       );
     }
 
@@ -3195,7 +4380,7 @@ export class Connection {
 
     const res = create(unsafeRes, GetFeeCalculatorRpcResult);
     if ('error' in res) {
-      throw new Error('failed to get fee calculator: ' + res.error.message);
+      throw new SolanaJSONRPCError(res.error, 'failed to get fee calculator');
     }
     const {context, value} = res.result;
     return {
@@ -3208,16 +4393,16 @@ export class Connection {
    * Fetch the fee for a message from the cluster, return with context
    */
   async getFeeForMessage(
-    message: Message,
+    message: VersionedMessage,
     commitment?: Commitment,
   ): Promise<RpcResponseAndContext<number>> {
-    const wireMessage = message.serialize().toString('base64');
+    const wireMessage = toBuffer(message.serialize()).toString('base64');
     const args = this._buildArgs([wireMessage], commitment);
     const unsafeRes = await this._rpcRequest('getFeeForMessage', args);
 
     const res = create(unsafeRes, jsonRpcResultAndContext(nullable(number())));
     if ('error' in res) {
-      throw new Error('failed to get slot: ' + res.error.message);
+      throw new SolanaJSONRPCError(res.error, 'failed to get fee for message');
     }
     if (res.result === null) {
       throw new Error('invalid blockhash');
@@ -3244,13 +4429,13 @@ export class Connection {
 
   /**
    * Fetch the latest blockhash from the cluster
-   * @return {Promise<{blockhash: Blockhash, lastValidBlockHeight: number}>}
+   * @return {Promise<BlockhashWithExpiryBlockHeight>}
    */
   async getLatestBlockhash(
-    commitment?: Commitment,
-  ): Promise<{blockhash: Blockhash; lastValidBlockHeight: number}> {
+    commitmentOrConfig?: Commitment | GetLatestBlockhashConfig,
+  ): Promise<BlockhashWithExpiryBlockHeight> {
     try {
-      const res = await this.getLatestBlockhashAndContext(commitment);
+      const res = await this.getLatestBlockhashAndContext(commitmentOrConfig);
       return res.value;
     } catch (e) {
       throw new Error('failed to get recent blockhash: ' + e);
@@ -3259,18 +4444,23 @@ export class Connection {
 
   /**
    * Fetch the latest blockhash from the cluster
-   * @return {Promise<{blockhash: Blockhash, lastValidBlockHeight: number}>}
+   * @return {Promise<BlockhashWithExpiryBlockHeight>}
    */
   async getLatestBlockhashAndContext(
-    commitment?: Commitment,
-  ): Promise<
-    RpcResponseAndContext<{blockhash: Blockhash; lastValidBlockHeight: number}>
-  > {
-    const args = this._buildArgs([], commitment);
+    commitmentOrConfig?: Commitment | GetLatestBlockhashConfig,
+  ): Promise<RpcResponseAndContext<BlockhashWithExpiryBlockHeight>> {
+    const {commitment, config} =
+      extractCommitmentFromConfig(commitmentOrConfig);
+    const args = this._buildArgs(
+      [],
+      commitment,
+      undefined /* encoding */,
+      config,
+    );
     const unsafeRes = await this._rpcRequest('getLatestBlockhash', args);
     const res = create(unsafeRes, GetLatestBlockhashRpcResult);
     if ('error' in res) {
-      throw new Error('failed to get latest blockhash: ' + res.error.message);
+      throw new SolanaJSONRPCError(res.error, 'failed to get latest blockhash');
     }
     return res.result;
   }
@@ -3282,7 +4472,7 @@ export class Connection {
     const unsafeRes = await this._rpcRequest('getVersion', []);
     const res = create(unsafeRes, jsonRpcResult(VersionResult));
     if ('error' in res) {
-      throw new Error('failed to get version: ' + res.error.message);
+      throw new SolanaJSONRPCError(res.error, 'failed to get version');
     }
     return res.result;
   }
@@ -3294,57 +4484,220 @@ export class Connection {
     const unsafeRes = await this._rpcRequest('getGenesisHash', []);
     const res = create(unsafeRes, jsonRpcResult(string()));
     if ('error' in res) {
-      throw new Error('failed to get genesis hash: ' + res.error.message);
+      throw new SolanaJSONRPCError(res.error, 'failed to get genesis hash');
     }
     return res.result;
   }
 
+  /**
+   * Fetch a processed block from the cluster.
+   *
+   * @deprecated Instead, call `getBlock` using a `GetVersionedBlockConfig` by
+   * setting the `maxSupportedTransactionVersion` property.
+   */
+  async getBlock(
+    slot: number,
+    rawConfig?: GetBlockConfig,
+  ): Promise<BlockResponse | null>;
+
+  /**
+   * @deprecated Instead, call `getBlock` using a `GetVersionedBlockConfig` by
+   * setting the `maxSupportedTransactionVersion` property.
+   */
+  // eslint-disable-next-line no-dupe-class-members
+  async getBlock(
+    slot: number,
+    rawConfig: GetBlockConfig & {transactionDetails: 'accounts'},
+  ): Promise<AccountsModeBlockResponse | null>;
+
+  /**
+   * @deprecated Instead, call `getBlock` using a `GetVersionedBlockConfig` by
+   * setting the `maxSupportedTransactionVersion` property.
+   */
+  // eslint-disable-next-line no-dupe-class-members
+  async getBlock(
+    slot: number,
+    rawConfig: GetBlockConfig & {transactionDetails: 'none'},
+  ): Promise<NoneModeBlockResponse | null>;
+
   /**
    * Fetch a processed block from the cluster.
    */
+  // eslint-disable-next-line no-dupe-class-members
+  async getBlock(
+    slot: number,
+    rawConfig?: GetVersionedBlockConfig,
+  ): Promise<VersionedBlockResponse | null>;
+
+  // eslint-disable-next-line no-dupe-class-members
+  async getBlock(
+    slot: number,
+    rawConfig: GetVersionedBlockConfig & {transactionDetails: 'accounts'},
+  ): Promise<VersionedAccountsModeBlockResponse | null>;
+
+  // eslint-disable-next-line no-dupe-class-members
   async getBlock(
     slot: number,
-    opts?: {commitment?: Finality},
-  ): Promise<BlockResponse | null> {
+    rawConfig: GetVersionedBlockConfig & {transactionDetails: 'none'},
+  ): Promise<VersionedNoneModeBlockResponse | null>;
+
+  /**
+   * Fetch a processed block from the cluster.
+   */
+  // eslint-disable-next-line no-dupe-class-members
+  async getBlock(
+    slot: number,
+    rawConfig?: GetVersionedBlockConfig,
+  ): Promise<
+    | VersionedBlockResponse
+    | VersionedAccountsModeBlockResponse
+    | VersionedNoneModeBlockResponse
+    | null
+  > {
+    const {commitment, config} = extractCommitmentFromConfig(rawConfig);
     const args = this._buildArgsAtLeastConfirmed(
       [slot],
-      opts && opts.commitment,
+      commitment as Finality,
+      undefined /* encoding */,
+      config,
     );
     const unsafeRes = await this._rpcRequest('getBlock', args);
-    const res = create(unsafeRes, GetBlockRpcResult);
-
-    if ('error' in res) {
-      throw new Error('failed to get confirmed block: ' + res.error.message);
+    try {
+      switch (config?.transactionDetails) {
+        case 'accounts': {
+          const res = create(unsafeRes, GetAccountsModeBlockRpcResult);
+          if ('error' in res) {
+            throw res.error;
+          }
+          return res.result;
+        }
+        case 'none': {
+          const res = create(unsafeRes, GetNoneModeBlockRpcResult);
+          if ('error' in res) {
+            throw res.error;
+          }
+          return res.result;
+        }
+        default: {
+          const res = create(unsafeRes, GetBlockRpcResult);
+          if ('error' in res) {
+            throw res.error;
+          }
+          const {result} = res;
+          return result
+            ? {
+                ...result,
+                transactions: result.transactions.map(
+                  ({transaction, meta, version}) => ({
+                    meta,
+                    transaction: {
+                      ...transaction,
+                      message: versionedMessageFromResponse(
+                        version,
+                        transaction.message,
+                      ),
+                    },
+                    version,
+                  }),
+                ),
+              }
+            : null;
+        }
+      }
+    } catch (e) {
+      throw new SolanaJSONRPCError(
+        e as JSONRPCError,
+        'failed to get confirmed block',
+      );
     }
+  }
 
-    const result = res.result;
-    if (!result) return result;
+  /**
+   * Fetch parsed transaction details for a confirmed or finalized block
+   */
+  async getParsedBlock(
+    slot: number,
+    rawConfig?: GetVersionedBlockConfig,
+  ): Promise<ParsedAccountsModeBlockResponse>;
 
-    return {
-      ...result,
-      transactions: result.transactions.map(({transaction, meta}) => {
-        const message = new Message(transaction.message);
-        return {
-          meta,
-          transaction: {
-            ...transaction,
-            message,
-          },
-        };
-      }),
-    };
+  // eslint-disable-next-line no-dupe-class-members
+  async getParsedBlock(
+    slot: number,
+    rawConfig: GetVersionedBlockConfig & {transactionDetails: 'accounts'},
+  ): Promise<ParsedAccountsModeBlockResponse>;
+
+  // eslint-disable-next-line no-dupe-class-members
+  async getParsedBlock(
+    slot: number,
+    rawConfig: GetVersionedBlockConfig & {transactionDetails: 'none'},
+  ): Promise<ParsedNoneModeBlockResponse>;
+  // eslint-disable-next-line no-dupe-class-members
+  async getParsedBlock(
+    slot: number,
+    rawConfig?: GetVersionedBlockConfig,
+  ): Promise<
+    | ParsedBlockResponse
+    | ParsedAccountsModeBlockResponse
+    | ParsedNoneModeBlockResponse
+    | null
+  > {
+    const {commitment, config} = extractCommitmentFromConfig(rawConfig);
+    const args = this._buildArgsAtLeastConfirmed(
+      [slot],
+      commitment as Finality,
+      'jsonParsed',
+      config,
+    );
+    const unsafeRes = await this._rpcRequest('getBlock', args);
+    try {
+      switch (config?.transactionDetails) {
+        case 'accounts': {
+          const res = create(unsafeRes, GetParsedAccountsModeBlockRpcResult);
+          if ('error' in res) {
+            throw res.error;
+          }
+          return res.result;
+        }
+        case 'none': {
+          const res = create(unsafeRes, GetParsedNoneModeBlockRpcResult);
+          if ('error' in res) {
+            throw res.error;
+          }
+          return res.result;
+        }
+        default: {
+          const res = create(unsafeRes, GetParsedBlockRpcResult);
+          if ('error' in res) {
+            throw res.error;
+          }
+          return res.result;
+        }
+      }
+    } catch (e) {
+      throw new SolanaJSONRPCError(e as JSONRPCError, 'failed to get block');
+    }
   }
 
   /*
    * Returns the current block height of the node
    */
-  async getBlockHeight(commitment?: Commitment): Promise<number> {
-    const args = this._buildArgs([], commitment);
+  async getBlockHeight(
+    commitmentOrConfig?: Commitment | GetBlockHeightConfig,
+  ): Promise<number> {
+    const {commitment, config} =
+      extractCommitmentFromConfig(commitmentOrConfig);
+    const args = this._buildArgs(
+      [],
+      commitment,
+      undefined /* encoding */,
+      config,
+    );
     const unsafeRes = await this._rpcRequest('getBlockHeight', args);
     const res = create(unsafeRes, jsonRpcResult(number()));
     if ('error' in res) {
-      throw new Error(
-        'failed to get block height information: ' + res.error.message,
+      throw new SolanaJSONRPCError(
+        res.error,
+        'failed to get block height information',
       );
     }
 
@@ -3372,8 +4725,9 @@ export class Connection {
     const unsafeRes = await this._rpcRequest('getBlockProduction', args);
     const res = create(unsafeRes, BlockProductionResponseStruct);
     if ('error' in res) {
-      throw new Error(
-        'failed to get block production information: ' + res.error.message,
+      throw new SolanaJSONRPCError(
+        res.error,
+        'failed to get block production information',
       );
     }
 
@@ -3382,19 +4736,44 @@ export class Connection {
 
   /**
    * Fetch a confirmed or finalized transaction from the cluster.
+   *
+   * @deprecated Instead, call `getTransaction` using a
+   * `GetVersionedTransactionConfig` by setting the
+   * `maxSupportedTransactionVersion` property.
    */
   async getTransaction(
     signature: string,
-    opts?: {commitment?: Finality},
-  ): Promise<TransactionResponse | null> {
+    rawConfig?: GetTransactionConfig,
+  ): Promise<TransactionResponse | null>;
+
+  /**
+   * Fetch a confirmed or finalized transaction from the cluster.
+   */
+  // eslint-disable-next-line no-dupe-class-members
+  async getTransaction(
+    signature: string,
+    rawConfig: GetVersionedTransactionConfig,
+  ): Promise<VersionedTransactionResponse | null>;
+
+  /**
+   * Fetch a confirmed or finalized transaction from the cluster.
+   */
+  // eslint-disable-next-line no-dupe-class-members
+  async getTransaction(
+    signature: string,
+    rawConfig?: GetVersionedTransactionConfig,
+  ): Promise<VersionedTransactionResponse | null> {
+    const {commitment, config} = extractCommitmentFromConfig(rawConfig);
     const args = this._buildArgsAtLeastConfirmed(
       [signature],
-      opts && opts.commitment,
+      commitment as Finality,
+      undefined /* encoding */,
+      config,
     );
     const unsafeRes = await this._rpcRequest('getTransaction', args);
     const res = create(unsafeRes, GetTransactionRpcResult);
     if ('error' in res) {
-      throw new Error('failed to get transaction: ' + res.error.message);
+      throw new SolanaJSONRPCError(res.error, 'failed to get transaction');
     }
 
     const result = res.result;
@@ -3404,7 +4783,10 @@ export class Connection {
       ...result,
       transaction: {
         ...result.transaction,
-        message: new Message(result.transaction.message),
+        message: versionedMessageFromResponse(
+          result.version,
+          result.transaction.message,
+        ),
       },
     };
   }
@@ -3414,17 +4796,20 @@ export class Connection {
    */
   async getParsedTransaction(
     signature: TransactionSignature,
-    commitment?: Finality,
-  ): Promise<ParsedConfirmedTransaction | null> {
+    commitmentOrConfig?: GetVersionedTransactionConfig | Finality,
+  ): Promise<ParsedTransactionWithMeta | null> {
+    const {commitment, config} =
+      extractCommitmentFromConfig(commitmentOrConfig);
     const args = this._buildArgsAtLeastConfirmed(
       [signature],
-      commitment,
+      commitment as Finality,
       'jsonParsed',
+      config,
     );
     const unsafeRes = await this._rpcRequest('getTransaction', args);
     const res = create(unsafeRes, GetParsedTransactionRpcResult);
     if ('error' in res) {
-      throw new Error('failed to get transaction: ' + res.error.message);
+      throw new SolanaJSONRPCError(res.error, 'failed to get transaction');
     }
     return res.result;
   }
@@ -3434,13 +4819,16 @@ export class Connection {
    */
   async getParsedTransactions(
     signatures: TransactionSignature[],
-    commitment?: Finality,
-  ): Promise<(ParsedConfirmedTransaction | null)[]> {
+    commitmentOrConfig?: GetVersionedTransactionConfig | Finality,
+  ): Promise<(ParsedTransactionWithMeta | null)[]> {
+    const {commitment, config} =
+      extractCommitmentFromConfig(commitmentOrConfig);
     const batch = signatures.map(signature => {
       const args = this._buildArgsAtLeastConfirmed(
         [signature],
-        commitment,
+        commitment as Finality,
         'jsonParsed',
+        config,
       );
       return {
         methodName: 'getTransaction',
@@ -3452,7 +4840,7 @@ export class Connection {
     const res = unsafeRes.map((unsafeRes: any) => {
       const res = create(unsafeRes, GetParsedTransactionRpcResult);
       if ('error' in res) {
-        throw new Error('failed to get transactions: ' + res.error.message);
+        throw new SolanaJSONRPCError(res.error, 'failed to get transactions');
       }
       return res.result;
     });
@@ -3460,6 +4848,79 @@ export class Connection {
     return res;
   }
 
+  /**
+   * Fetch transaction details for a batch of confirmed transactions.
+   * Similar to {@link getParsedTransactions} but returns a {@link TransactionResponse}.
+   *
+   * @deprecated Instead, call `getTransactions` using a
+   * `GetVersionedTransactionConfig` by setting the
+   * `maxSupportedTransactionVersion` property.
+   */
+  async getTransactions(
+    signatures: TransactionSignature[],
+    commitmentOrConfig?: GetTransactionConfig | Finality,
+  ): Promise<(TransactionResponse | null)[]>;
+
+  /**
+   * Fetch transaction details for a batch of confirmed transactions.
+   * Similar to {@link getParsedTransactions} but returns a {@link
+   * VersionedTransactionResponse}.
+   */
+  // eslint-disable-next-line no-dupe-class-members
+  async getTransactions(
+    signatures: TransactionSignature[],
+    commitmentOrConfig: GetVersionedTransactionConfig | Finality,
+  ): Promise<(VersionedTransactionResponse | null)[]>;
+
+  /**
+   * Fetch transaction details for a batch of confirmed transactions.
+   * Similar to {@link getParsedTransactions} but returns a {@link
+   * VersionedTransactionResponse}.
+   */
+  // eslint-disable-next-line no-dupe-class-members
+  async getTransactions(
+    signatures: TransactionSignature[],
+    commitmentOrConfig: GetVersionedTransactionConfig | Finality,
+  ): Promise<(VersionedTransactionResponse | null)[]> {
+    const {commitment, config} =
+      extractCommitmentFromConfig(commitmentOrConfig);
+    const batch = signatures.map(signature => {
+      const args = this._buildArgsAtLeastConfirmed(
+        [signature],
+        commitment as Finality,
+        undefined /* encoding */,
+        config,
+      );
+      return {
+        methodName: 'getTransaction',
+        args,
+      };
+    });
+
+    const unsafeRes = await this._rpcBatchRequest(batch);
+    const res = unsafeRes.map((unsafeRes: any) => {
+      const res = create(unsafeRes, GetTransactionRpcResult);
+      if ('error' in res) {
+        throw new SolanaJSONRPCError(res.error, 'failed to get transactions');
+      }
+      const result = res.result;
+      if (!result) return result;
+
+      return {
+        ...result,
+        transaction: {
+          ...result.transaction,
+          message: versionedMessageFromResponse(
+            result.version,
+            result.transaction.message,
+          ),
+        },
+      };
+    });
+
+    return res;
+  }
+
   /**
    * Fetch a list of Transactions and transaction statuses from the cluster
    * for a confirmed block.
@@ -3475,7 +4936,7 @@ export class Connection {
     const res = create(unsafeRes, GetConfirmedBlockRpcResult);
 
     if ('error' in res) {
-      throw new Error('failed to get confirmed block: ' + res.error.message);
+      throw new SolanaJSONRPCError(res.error, 'failed to get confirmed block');
     }
 
     const result = res.result;
@@ -3526,7 +4987,7 @@ export class Connection {
     const unsafeRes = await this._rpcRequest('getBlocks', args);
     const res = create(unsafeRes, jsonRpcResult(array(number())));
     if ('error' in res) {
-      throw new Error('failed to get blocks: ' + res.error.message);
+      throw new SolanaJSONRPCError(res.error, 'failed to get blocks');
     }
     return res.result;
   }
@@ -3550,7 +5011,7 @@ export class Connection {
     const unsafeRes = await this._rpcRequest('getBlock', args);
     const res = create(unsafeRes, GetBlockSignaturesRpcResult);
     if ('error' in res) {
-      throw new Error('failed to get block: ' + res.error.message);
+      throw new SolanaJSONRPCError(res.error, 'failed to get block');
     }
     const result = res.result;
     if (!result) {
@@ -3580,7 +5041,7 @@ export class Connection {
     const unsafeRes = await this._rpcRequest('getConfirmedBlock', args);
     const res = create(unsafeRes, GetBlockSignaturesRpcResult);
     if ('error' in res) {
-      throw new Error('failed to get confirmed block: ' + res.error.message);
+      throw new SolanaJSONRPCError(res.error, 'failed to get confirmed block');
     }
     const result = res.result;
     if (!result) {
@@ -3602,7 +5063,7 @@ export class Connection {
     const unsafeRes = await this._rpcRequest('getConfirmedTransaction', args);
     const res = create(unsafeRes, GetTransactionRpcResult);
     if ('error' in res) {
-      throw new Error('failed to get transaction: ' + res.error.message);
+      throw new SolanaJSONRPCError(res.error, 'failed to get transaction');
     }
 
     const result = res.result;
@@ -3633,8 +5094,9 @@ export class Connection {
     const unsafeRes = await this._rpcRequest('getConfirmedTransaction', args);
     const res = create(unsafeRes, GetParsedTransactionRpcResult);
     if ('error' in res) {
-      throw new Error(
-        'failed to get confirmed transaction: ' + res.error.message,
+      throw new SolanaJSONRPCError(
+        res.error,
+        'failed to get confirmed transaction',
       );
     }
     return res.result;
@@ -3665,8 +5127,9 @@ export class Connection {
     const res = unsafeRes.map((unsafeRes: any) => {
       const res = create(unsafeRes, GetParsedTransactionRpcResult);
       if ('error' in res) {
-        throw new Error(
-          'failed to get confirmed transactions: ' + res.error.message,
+        throw new SolanaJSONRPCError(
+          res.error,
+          'failed to get confirmed transactions',
         );
       }
       return res.result;
@@ -3771,8 +5234,9 @@ export class Connection {
     );
     const res = create(unsafeRes, GetConfirmedSignaturesForAddress2RpcResult);
     if ('error' in res) {
-      throw new Error(
-        'failed to get confirmed signatures for address: ' + res.error.message,
+      throw new SolanaJSONRPCError(
+        res.error,
+        'failed to get confirmed signatures for address',
       );
     }
     return res.result;
@@ -3800,23 +5264,47 @@ export class Connection {
     const unsafeRes = await this._rpcRequest('getSignaturesForAddress', args);
     const res = create(unsafeRes, GetSignaturesForAddressRpcResult);
     if ('error' in res) {
-      throw new Error(
-        'failed to get signatures for address: ' + res.error.message,
+      throw new SolanaJSONRPCError(
+        res.error,
+        'failed to get signatures for address',
       );
     }
     return res.result;
   }
 
+  async getAddressLookupTable(
+    accountKey: PublicKey,
+    config?: GetAccountInfoConfig,
+  ): Promise<RpcResponseAndContext<AddressLookupTableAccount | null>> {
+    const {context, value: accountInfo} = await this.getAccountInfoAndContext(
+      accountKey,
+      config,
+    );
+
+    let value = null;
+    if (accountInfo !== null) {
+      value = new AddressLookupTableAccount({
+        key: accountKey,
+        state: AddressLookupTableAccount.deserialize(accountInfo.data),
+      });
+    }
+
+    return {
+      context,
+      value,
+    };
+  }
+
   /**
    * Fetch the contents of a Nonce account from the cluster, return with context
    */
   async getNonceAndContext(
     nonceAccount: PublicKey,
-    commitment?: Commitment,
+    commitmentOrConfig?: Commitment | GetNonceAndContextConfig,
   ): Promise<RpcResponseAndContext<NonceAccount | null>> {
     const {context, value: accountInfo} = await this.getAccountInfoAndContext(
       nonceAccount,
-      commitment,
+      commitmentOrConfig,
     );
 
     let value = null;
@@ -3835,9 +5323,9 @@ export class Connection {
    */
   async getNonce(
     nonceAccount: PublicKey,
-    commitment?: Commitment,
+    commitmentOrConfig?: Commitment | GetNonceConfig,
   ): Promise<NonceAccount | null> {
-    return await this.getNonceAndContext(nonceAccount, commitment)
+    return await this.getNonceAndContext(nonceAccount, commitmentOrConfig)
       .then(x => x.value)
       .catch(e => {
         throw new Error(
@@ -3873,8 +5361,9 @@ export class Connection {
     ]);
     const res = create(unsafeRes, RequestAirdropRpcResult);
     if ('error' in res) {
-      throw new Error(
-        'airdrop to ' + to.toBase58() + ' failed: ' + res.error.message,
+      throw new SolanaJSONRPCError(
+        res.error,
+        `airdrop to ${to.toBase58()} failed`,
       );
     }
     return res.result;
@@ -3883,7 +5372,9 @@ export class Connection {
   /**
    * @internal
    */
-  async _recentBlockhash(disableCache: boolean): Promise<Blockhash> {
+  async _blockhashWithExpiryBlockHeight(
+    disableCache: boolean,
+  ): Promise<BlockhashWithExpiryBlockHeight> {
     if (!disableCache) {
       // Wait for polling to finish
       while (this._pollingBlockhash) {
@@ -3891,8 +5382,8 @@ export class Connection {
       }
       const timeSinceFetch = Date.now() - this._blockhashInfo.lastFetch;
       const expired = timeSinceFetch >= BLOCKHASH_CACHE_TIMEOUT_MS;
-      if (this._blockhashInfo.recentBlockhash !== null && !expired) {
-        return this._blockhashInfo.recentBlockhash;
+      if (this._blockhashInfo.latestBlockhash !== null && !expired) {
+        return this._blockhashInfo.latestBlockhash;
       }
     }
 
@@ -3902,21 +5393,25 @@ export class Connection {
   /**
    * @internal
    */
-  async _pollNewBlockhash(): Promise<Blockhash> {
+  async _pollNewBlockhash(): Promise<BlockhashWithExpiryBlockHeight> {
     this._pollingBlockhash = true;
     try {
       const startTime = Date.now();
+      const cachedLatestBlockhash = this._blockhashInfo.latestBlockhash;
+      const cachedBlockhash = cachedLatestBlockhash
+        ? cachedLatestBlockhash.blockhash
+        : null;
       for (let i = 0; i < 50; i++) {
-        const {blockhash} = await this.getRecentBlockhash('finalized');
+        const latestBlockhash = await this.getLatestBlockhash('finalized');
 
-        if (this._blockhashInfo.recentBlockhash != blockhash) {
+        if (cachedBlockhash !== latestBlockhash.blockhash) {
           this._blockhashInfo = {
-            recentBlockhash: blockhash,
+            latestBlockhash,
             lastFetch: Date.now(),
             transactionSignatures: [],
             simulatedSignatures: [],
           };
-          return blockhash;
+          return latestBlockhash;
         }
 
         // Sleep for approximately half a slot
@@ -3931,36 +5426,108 @@ export class Connection {
     }
   }
 
+  /**
+   * get the stake minimum delegation
+   */
+  async getStakeMinimumDelegation(
+    config?: GetStakeMinimumDelegationConfig,
+  ): Promise<RpcResponseAndContext<number>> {
+    const {commitment, config: configArg} = extractCommitmentFromConfig(config);
+    const args = this._buildArgs([], commitment, 'base64', configArg);
+    const unsafeRes = await this._rpcRequest('getStakeMinimumDelegation', args);
+    const res = create(unsafeRes, jsonRpcResultAndContext(number()));
+    if ('error' in res) {
+      throw new SolanaJSONRPCError(
+        res.error,
+        `failed to get stake minimum delegation`,
+      );
+    }
+    return res.result;
+  }
+
   /**
    * Simulate a transaction
+   *
+   * @deprecated Instead, call {@link simulateTransaction} with {@link
+   * VersionedTransaction} and {@link SimulateTransactionConfig} parameters
    */
-  async simulateTransaction(
+  simulateTransaction(
     transactionOrMessage: Transaction | Message,
     signers?: Array<Signer>,
     includeAccounts?: boolean | Array<PublicKey>,
+  ): Promise<RpcResponseAndContext<SimulatedTransactionResponse>>;
+
+  /**
+   * Simulate a transaction
+   */
+  // eslint-disable-next-line no-dupe-class-members
+  simulateTransaction(
+    transaction: VersionedTransaction,
+    config?: SimulateTransactionConfig,
+  ): Promise<RpcResponseAndContext<SimulatedTransactionResponse>>;
+
+  /**
+   * Simulate a transaction
+   */
+  // eslint-disable-next-line no-dupe-class-members
+  async simulateTransaction(
+    transactionOrMessage: VersionedTransaction | Transaction | Message,
+    configOrSigners?: SimulateTransactionConfig | Array<Signer>,
+    includeAccounts?: boolean | Array<PublicKey>,
   ): Promise<RpcResponseAndContext<SimulatedTransactionResponse>> {
+    if ('message' in transactionOrMessage) {
+      const versionedTx = transactionOrMessage;
+      const wireTransaction = versionedTx.serialize();
+      const encodedTransaction =
+        Buffer.from(wireTransaction).toString('base64');
+      if (Array.isArray(configOrSigners) || includeAccounts !== undefined) {
+        throw new Error('Invalid arguments');
+      }
+
+      const config: any = configOrSigners || {};
+      config.encoding = 'base64';
+      if (!('commitment' in config)) {
+        config.commitment = this.commitment;
+      }
+
+      const args = [encodedTransaction, config];
+      const unsafeRes = await this._rpcRequest('simulateTransaction', args);
+      const res = create(unsafeRes, SimulatedTransactionResponseStruct);
+      if ('error' in res) {
+        throw new Error('failed to simulate transaction: ' + res.error.message);
+      }
+      return res.result;
+    }
+
     let transaction;
     if (transactionOrMessage instanceof Transaction) {
       let originalTx: Transaction = transactionOrMessage;
-      transaction = new Transaction({
-        recentBlockhash: originalTx.recentBlockhash,
-        nonceInfo: originalTx.nonceInfo,
-        feePayer: originalTx.feePayer,
-        signatures: [...originalTx.signatures],
-      });
+      transaction = new Transaction();
+      transaction.feePayer = originalTx.feePayer;
       transaction.instructions = transactionOrMessage.instructions;
+      transaction.nonceInfo = originalTx.nonceInfo;
+      transaction.signatures = originalTx.signatures;
     } else {
       transaction = Transaction.populate(transactionOrMessage);
       // HACK: this function relies on mutating the populated transaction
       transaction._message = transaction._json = undefined;
     }
 
+    if (configOrSigners !== undefined && !Array.isArray(configOrSigners)) {
+      throw new Error('Invalid arguments');
+    }
+
+    const signers = configOrSigners;
     if (transaction.nonceInfo && signers) {
       transaction.sign(...signers);
     } else {
       let disableCache = this._disableBlockhashCaching;
       for (;;) {
-        transaction.recentBlockhash = await this._recentBlockhash(disableCache);
+        const latestBlockhash = await this._blockhashWithExpiryBlockHeight(
+          disableCache,
+        );
+        transaction.lastValidBlockHeight = latestBlockhash.lastValidBlockHeight;
+        transaction.recentBlockhash = latestBlockhash.blockhash;
 
         if (!signers) break;
 
@@ -4037,18 +5604,58 @@ export class Connection {
 
   /**
    * Sign and send a transaction
+   *
+   * @deprecated Instead, call {@link sendTransaction} with a {@link
+   * VersionedTransaction}
    */
-  async sendTransaction(
+  sendTransaction(
     transaction: Transaction,
     signers: Array<Signer>,
     options?: SendOptions,
+  ): Promise<TransactionSignature>;
+
+  /**
+   * Send a signed transaction
+   */
+  // eslint-disable-next-line no-dupe-class-members
+  sendTransaction(
+    transaction: VersionedTransaction,
+    options?: SendOptions,
+  ): Promise<TransactionSignature>;
+
+  /**
+   * Sign and send a transaction
+   */
+  // eslint-disable-next-line no-dupe-class-members
+  async sendTransaction(
+    transaction: VersionedTransaction | Transaction,
+    signersOrOptions?: Array<Signer> | SendOptions,
+    options?: SendOptions,
   ): Promise<TransactionSignature> {
+    if ('version' in transaction) {
+      if (signersOrOptions && Array.isArray(signersOrOptions)) {
+        throw new Error('Invalid arguments');
+      }
+
+      const wireTransaction = transaction.serialize();
+      return await this.sendRawTransaction(wireTransaction, options);
+    }
+
+    if (signersOrOptions === undefined || !Array.isArray(signersOrOptions)) {
+      throw new Error('Invalid arguments');
+    }
+
+    const signers = signersOrOptions;
     if (transaction.nonceInfo) {
       transaction.sign(...signers);
     } else {
       let disableCache = this._disableBlockhashCaching;
       for (;;) {
-        transaction.recentBlockhash = await this._recentBlockhash(disableCache);
+        const latestBlockhash = await this._blockhashWithExpiryBlockHeight(
+          disableCache,
+        );
+        transaction.lastValidBlockHeight = latestBlockhash.lastValidBlockHeight;
+        transaction.recentBlockhash = latestBlockhash.blockhash;
         transaction.sign(...signers);
         if (!transaction.signature) {
           throw new Error('!signature'); // should never happen
@@ -4103,9 +5710,12 @@ export class Connection {
     const preflightCommitment =
       (options && options.preflightCommitment) || this.commitment;
 
-    if (options && options.maxRetries) {
+    if (options && options.maxRetries != null) {
       config.maxRetries = options.maxRetries;
     }
+    if (options && options.minContextSlot != null) {
+      config.minContextSlot = options.minContextSlot;
+    }
     if (skipPreflight) {
       config.skipPreflight = skipPreflight;
     }
@@ -4145,6 +5755,7 @@ export class Connection {
    * @internal
    */
   _wsOnError(err: Error) {
+    this._rpcWebSocketConnected = false;
     console.error('ws error:', err.message);
   }
 
@@ -4152,6 +5763,13 @@ export class Connection {
    * @internal
    */
   _wsOnClose(code: number) {
+    this._rpcWebSocketConnected = false;
+    this._rpcWebSocketGeneration =
+      (this._rpcWebSocketGeneration + 1) % Number.MAX_SAFE_INTEGER;
+    if (this._rpcWebSocketIdleTimeout) {
+      clearTimeout(this._rpcWebSocketIdleTimeout);
+      this._rpcWebSocketIdleTimeout = null;
+    }
     if (this._rpcWebSocketHeartbeat) {
       clearInterval(this._rpcWebSocketHeartbeat);
       this._rpcWebSocketHeartbeat = null;
@@ -4168,13 +5786,60 @@ export class Connection {
     Object.entries(
       this._subscriptionsByHash as Record<SubscriptionConfigHash, Subscription>,
     ).forEach(([hash, subscription]) => {
-      this._subscriptionsByHash[hash] = {
+      this._setSubscription(hash, {
         ...subscription,
         state: 'pending',
-      };
+      });
     });
   }
 
+  /**
+   * @internal
+   */
+  private _setSubscription(
+    hash: SubscriptionConfigHash,
+    nextSubscription: Subscription,
+  ) {
+    const prevState = this._subscriptionsByHash[hash]?.state;
+    this._subscriptionsByHash[hash] = nextSubscription;
+    if (prevState !== nextSubscription.state) {
+      const stateChangeCallbacks =
+        this._subscriptionStateChangeCallbacksByHash[hash];
+      if (stateChangeCallbacks) {
+        stateChangeCallbacks.forEach(cb => {
+          try {
+            cb(nextSubscription.state);
+            // eslint-disable-next-line no-empty
+          } catch {}
+        });
+      }
+    }
+  }
+
+  /**
+   * @internal
+   */
+  private _onSubscriptionStateChange(
+    clientSubscriptionId: ClientSubscriptionId,
+    callback: SubscriptionStateChangeCallback,
+  ): SubscriptionStateChangeDisposeFn {
+    const hash =
+      this._subscriptionHashByClientSubscriptionId[clientSubscriptionId];
+    if (hash == null) {
+      return () => {};
+    }
+    const stateChangeCallbacks = (this._subscriptionStateChangeCallbacksByHash[
+      hash
+    ] ||= new Set());
+    stateChangeCallbacks.add(callback);
+    return () => {
+      stateChangeCallbacks.delete(callback);
+      if (stateChangeCallbacks.size === 0) {
+        delete this._subscriptionStateChangeCallbacksByHash[hash];
+      }
+    };
+  }
+
   /**
    * @internal
    */
@@ -4210,13 +5875,22 @@ export class Connection {
       return;
     }
 
+    const activeWebSocketGeneration = this._rpcWebSocketGeneration;
+    const isCurrentConnectionStillActive = () => {
+      return activeWebSocketGeneration === this._rpcWebSocketGeneration;
+    };
+
     await Promise.all(
-      Object.entries(
-        this._subscriptionsByHash as Record<
-          SubscriptionConfigHash,
-          Subscription
-        >,
-      ).map(async ([hash, subscription]) => {
+      // Don't be tempted to change this to `Object.entries`. We call
+      // `_updateSubscriptions` recursively when processing the state,
+      // so it's important that we look up the *current* version of
+      // each subscription, every time we process a hash.
+      Object.keys(this._subscriptionsByHash).map(async hash => {
+        const subscription = this._subscriptionsByHash[hash];
+        if (subscription === undefined) {
+          // This entry has since been deleted. Skip.
+          return;
+        }
         switch (subscription.state) {
           case 'pending':
           case 'unsubscribed':
@@ -4244,62 +5918,23 @@ export class Connection {
               return;
             }
             await (async () => {
-              const {method, params} = subscription;
-              let args: IWSRequestParams;
-              switch (method) {
-                case 'accountSubscribe':
-                  args = this._buildArgs(
-                    [params.publicKey],
-                    params.commitment,
-                    'base64',
-                  );
-                  break;
-                case 'logsSubscribe':
-                  args = this._buildArgs(
-                    [
-                      typeof params.filter === 'object'
-                        ? {mentions: [params.filter.toString()]}
-                        : params.filter,
-                    ],
-                    params.commitment,
-                  );
-                  break;
-                case 'programSubscribe':
-                  args = this._buildArgs(
-                    [params.programId],
-                    params.commitment,
-                    'base64',
-                    params.filters
-                      ? {
-                          filters: params.filters,
-                        }
-                      : undefined,
-                  );
-                  break;
-                case 'signatureSubscribe':
-                  args = [params.signature, params.options].filter(Boolean);
-                  break;
-                case 'rootSubscribe':
-                case 'slotSubscribe':
-                case 'slotsUpdatesSubscribe':
-                  args = [];
-                  break;
-              }
+              const {args, method} = subscription;
               try {
-                this._subscriptionsByHash[hash] = {
+                this._setSubscription(hash, {
                   ...subscription,
                   state: 'subscribing',
-                };
+                });
                 const serverSubscriptionId: ServerSubscriptionId =
                   (await this._rpcWebSocket.call(method, args)) as number;
-                this._subscriptionsByHash[hash] = {
+                this._setSubscription(hash, {
                   ...subscription,
                   serverSubscriptionId,
                   state: 'subscribed',
-                };
+                });
                 this._subscriptionCallbacksByServerSubscriptionId[
                   serverSubscriptionId
                 ] = subscription.callbacks;
+                await this._updateSubscriptions();
               } catch (e) {
                 if (e instanceof Error) {
                   console.error(
@@ -4308,12 +5943,14 @@ export class Connection {
                     e.message,
                   );
                 }
+                if (!isCurrentConnectionStillActive()) {
+                  return;
+                }
                 // TODO: Maybe add an 'errored' state or a retry limit?
-                this._subscriptionsByHash[hash] = {
+                this._setSubscription(hash, {
                   ...subscription,
                   state: 'pending',
-                };
-              } finally {
+                });
                 await this._updateSubscriptions();
               }
             })();
@@ -4341,10 +5978,14 @@ export class Connection {
                     serverSubscriptionId,
                   );
                 } else {
-                  this._subscriptionsByHash[hash] = {
+                  this._setSubscription(hash, {
+                    ...subscription,
+                    state: 'unsubscribing',
+                  });
+                  this._setSubscription(hash, {
                     ...subscription,
                     state: 'unsubscribing',
-                  };
+                  });
                   try {
                     await this._rpcWebSocket.call(unsubscribeMethod, [
                       serverSubscriptionId,
@@ -4353,19 +5994,22 @@ export class Connection {
                     if (e instanceof Error) {
                       console.error(`${unsubscribeMethod} error:`, e.message);
                     }
+                    if (!isCurrentConnectionStillActive()) {
+                      return;
+                    }
                     // TODO: Maybe add an 'errored' state or a retry limit?
-                    this._subscriptionsByHash[hash] = {
+                    this._setSubscription(hash, {
                       ...subscription,
                       state: 'subscribed',
-                    };
+                    });
                     await this._updateSubscriptions();
                     return;
                   }
                 }
-                this._subscriptionsByHash[hash] = {
+                this._setSubscription(hash, {
                   ...subscription,
                   state: 'unsubscribed',
-                };
+                });
                 await this._updateSubscriptions();
               })();
             }
@@ -4379,21 +6023,28 @@ export class Connection {
   }
 
   /**
-   *
    * @internal
    */
-  _publishNotification<TCallback extends SubscriptionConfig['callback']>(
+  private _handleServerNotification<
+    TCallback extends SubscriptionConfig['callback'],
+  >(
     serverSubscriptionId: ServerSubscriptionId,
-    publishArgs: Parameters<TCallback>,
+    callbackArgs: Parameters<TCallback>,
   ): void {
     const callbacks =
       this._subscriptionCallbacksByServerSubscriptionId[serverSubscriptionId];
-    if (callbacks == null) {
+    if (callbacks === undefined) {
       return;
     }
     callbacks.forEach(cb => {
       try {
-        cb(...(publishArgs as [any, any]));
+        cb(
+          // I failed to find a way to convince TypeScript that `cb` is of type
+          // `TCallback` which is certainly compatible with `Parameters<TCallback>`.
+          // See https://github.com/microsoft/TypeScript/issues/47615
+          // @ts-ignore
+          ...callbackArgs,
+        );
       } catch (e) {
         console.error(e);
       }
@@ -4408,85 +6059,70 @@ export class Connection {
       notification,
       AccountNotificationResult,
     );
-    this._publishNotification<AccountChangeCallback>(subscription, [
+    this._handleServerNotification<AccountChangeCallback>(subscription, [
       result.value,
       result.context,
     ]);
   }
 
   /**
-   * @private
+   * @internal
    */
-  _makeSubscription(
-    // The subscription config, before applying defaults
-    rawConfig: SubscriptionConfig,
+  private _makeSubscription(
+    subscriptionConfig: SubscriptionConfig,
+    /**
+     * When preparing `args` for a call to `_makeSubscription`, be sure
+     * to carefully apply a default `commitment` property, if necessary.
+     *
+     * - If the user supplied a `commitment` use that.
+     * - Otherwise, if the `Connection::commitment` is set, use that.
+     * - Otherwise, set it to the RPC server default: `finalized`.
+     *
+     * This is extremely important to ensure that these two fundamentally
+     * identical subscriptions produce the same identifying hash:
+     *
+     * - A subscription made without specifying a commitment.
+     * - A subscription made where the commitment specified is the same
+     *   as the default applied to the subscription above.
+     *
+     * Example; these two subscriptions must produce the same hash:
+     *
+     * - An `accountSubscribe` subscription for `'PUBKEY'`
+     * - An `accountSubscribe` subscription for `'PUBKEY'` with commitment
+     *   `'finalized'`.
+     *
+     * See the 'making a subscription with defaulted params omitted' test
+     * in `connection-subscriptions.ts` for more.
+     */
+    args: IWSRequestParams,
   ): ClientSubscriptionId {
     const clientSubscriptionId = this._nextClientSubscriptionId++;
-    let subscriptionConfig: SubscriptionConfig;
-    // Apply defaults.
-    switch (rawConfig.method) {
-      case 'accountSubscribe':
-      case 'logsSubscribe':
-      case 'programSubscribe':
-        if (rawConfig.params.commitment === undefined) {
-          subscriptionConfig = {
-            ...rawConfig,
-            params: {
-              ...rawConfig.params,
-              commitment: 'finalized',
-            },
-          } as SubscriptionConfig;
-        } else {
-          subscriptionConfig = rawConfig;
-        }
-        break;
-      case 'signatureSubscribe':
-        if (
-          rawConfig.params.options &&
-          rawConfig.params.options.commitment === undefined
-        ) {
-          subscriptionConfig = {
-            ...rawConfig,
-            params: {
-              ...rawConfig.params,
-              options: {
-                ...rawConfig.params.options,
-                commitment: 'finalized',
-              },
-            },
-          };
-        } else {
-          subscriptionConfig = rawConfig;
-        }
-        break;
-      default:
-        subscriptionConfig = rawConfig;
-    }
-    const hash = hashSubscriptionConfig(subscriptionConfig);
+    const hash = fastStableStringify(
+      [subscriptionConfig.method, args],
+      true /* isArrayProp */,
+    );
     const existingSubscription = this._subscriptionsByHash[hash];
-    if (existingSubscription == null) {
+    if (existingSubscription === undefined) {
       this._subscriptionsByHash[hash] = {
         ...subscriptionConfig,
+        args,
         callbacks: new Set([subscriptionConfig.callback]),
         state: 'pending',
       };
     } else {
       existingSubscription.callbacks.add(subscriptionConfig.callback);
     }
-    let unsubscribed = false;
+    this._subscriptionHashByClientSubscriptionId[clientSubscriptionId] = hash;
     this._subscriptionDisposeFunctionsByClientSubscriptionId[
       clientSubscriptionId
     ] = async () => {
-      if (unsubscribed) {
-        return;
-      }
-      unsubscribed = true;
       delete this._subscriptionDisposeFunctionsByClientSubscriptionId[
         clientSubscriptionId
       ];
+      delete this._subscriptionHashByClientSubscriptionId[clientSubscriptionId];
       const subscription = this._subscriptionsByHash[hash];
       assert(
-        subscription,
+        subscription !== undefined,
         `Could not find a \`Subscription\` when tearing down client subscription #${clientSubscriptionId}`,
       );
       subscription.callbacks.delete(subscriptionConfig.callback);
@@ -4509,15 +6145,19 @@ export class Connection {
     callback: AccountChangeCallback,
     commitment?: Commitment,
   ): ClientSubscriptionId {
-    return this._makeSubscription({
-      callback,
-      method: 'accountSubscribe',
-      params: {
-        commitment,
-        publicKey: publicKey.toBase58(),
+    const args = this._buildArgs(
+      [publicKey.toBase58()],
+      commitment || this._commitment || 'finalized', // Apply connection/server default.
+      'base64',
+    );
+    return this._makeSubscription(
+      {
+        callback,
+        method: 'accountSubscribe',
+        unsubscribeMethod: 'accountUnsubscribe',
       },
-      unsubscribeMethod: 'accountUnsubscribe',
-    });
+      args,
+    );
   }
 
   /**
@@ -4542,7 +6182,7 @@ export class Connection {
       notification,
       ProgramAccountNotificationResult,
     );
-    this._publishNotification<ProgramAccountChangeCallback>(subscription, [
+    this._handleServerNotification<ProgramAccountChangeCallback>(subscription, [
       {
         accountId: result.value.pubkey,
         accountInfo: result.value.account,
@@ -4567,16 +6207,20 @@ export class Connection {
     commitment?: Commitment,
     filters?: GetProgramAccountsFilter[],
   ): ClientSubscriptionId {
-    return this._makeSubscription({
-      callback,
-      method: 'programSubscribe',
-      params: {
-        commitment,
-        filters,
-        programId: programId.toBase58(),
+    const args = this._buildArgs(
+      [programId.toBase58()],
+      commitment || this._commitment || 'finalized', // Apply connection/server default.
+      'base64' /* encoding */,
+      filters ? {filters: filters} : undefined /* extra */,
+    );
+    return this._makeSubscription(
+      {
+        callback,
+        method: 'programSubscribe',
+        unsubscribeMethod: 'programUnsubscribe',
       },
-      unsubscribeMethod: 'programUnsubscribe',
-    });
+      args,
+    );
   }
 
   /**
@@ -4601,15 +6245,18 @@ export class Connection {
     callback: LogsCallback,
     commitment?: Commitment,
   ): ClientSubscriptionId {
-    return this._makeSubscription({
-      callback,
-      method: 'logsSubscribe',
-      params: {
-        commitment,
-        filter,
+    const args = this._buildArgs(
+      [typeof filter === 'object' ? {mentions: [filter.toString()]} : filter],
+      commitment || this._commitment || 'finalized', // Apply connection/server default.
+    );
+    return this._makeSubscription(
+      {
+        callback,
+        method: 'logsSubscribe',
+        unsubscribeMethod: 'logsUnsubscribe',
       },
-      unsubscribeMethod: 'logsUnsubscribe',
-    });
+      args,
+    );
   }
 
   /**
@@ -4628,7 +6275,7 @@ export class Connection {
    */
   _wsOnLogsNotification(notification: Object) {
     const {result, subscription} = create(notification, LogsNotificationResult);
-    this._publishNotification<LogsCallback>(subscription, [
+    this._handleServerNotification<LogsCallback>(subscription, [
       result.value,
       result.context,
     ]);
@@ -4639,7 +6286,7 @@ export class Connection {
    */
   _wsOnSlotNotification(notification: Object) {
     const {result, subscription} = create(notification, SlotNotificationResult);
-    this._publishNotification<SlotChangeCallback>(subscription, [result]);
+    this._handleServerNotification<SlotChangeCallback>(subscription, [result]);
   }
 
   /**
@@ -4649,12 +6296,14 @@ export class Connection {
    * @return subscription id
    */
   onSlotChange(callback: SlotChangeCallback): ClientSubscriptionId {
-    return this._makeSubscription({
-      callback,
-      method: 'slotSubscribe',
-      params: undefined,
-      unsubscribeMethod: 'slotUnsubscribe',
-    });
+    return this._makeSubscription(
+      {
+        callback,
+        method: 'slotSubscribe',
+        unsubscribeMethod: 'slotUnsubscribe',
+      },
+      [] /* args */,
+    );
   }
 
   /**
@@ -4679,7 +6328,7 @@ export class Connection {
       notification,
       SlotUpdateNotificationResult,
     );
-    this._publishNotification<SlotUpdateCallback>(subscription, [result]);
+    this._handleServerNotification<SlotUpdateCallback>(subscription, [result]);
   }
 
   /**
@@ -4690,12 +6339,14 @@ export class Connection {
    * @return subscription id
    */
   onSlotUpdate(callback: SlotUpdateCallback): ClientSubscriptionId {
-    return this._makeSubscription({
-      callback,
-      method: 'slotsUpdatesSubscribe',
-      params: undefined,
-      unsubscribeMethod: 'slotsUpdatesUnsubscribe',
-    });
+    return this._makeSubscription(
+      {
+        callback,
+        method: 'slotsUpdatesSubscribe',
+        unsubscribeMethod: 'slotsUpdatesUnsubscribe',
+      },
+      [] /* args */,
+    );
   }
 
   /**
@@ -4716,7 +6367,7 @@ export class Connection {
    * @internal
    */
 
-  async _unsubscribeClientSubscription(
+  private async _unsubscribeClientSubscription(
     clientSubscriptionId: ClientSubscriptionId,
     subscriptionName: string,
   ) {
@@ -4727,8 +6378,10 @@ export class Connection {
     if (dispose) {
       await dispose();
     } else {
-      throw new Error(
-        `Unknown ${subscriptionName} client subscription id: ${clientSubscriptionId}`,
+      console.warn(
+        'Ignored unsubscribe request because an active subscription with id ' +
+          `\`${clientSubscriptionId}\` for '${subscriptionName}' events ` +
+          'could not be found.',
       );
     }
   }
@@ -4800,7 +6453,7 @@ export class Connection {
        */
       this._subscriptionsAutoDisposedByRpc.add(subscription);
     }
-    this._publishNotification<SignatureSubscriptionCallback>(
+    this._handleServerNotification<SignatureSubscriptionCallback>(
       subscription,
       result.value === 'receivedSignature'
         ? [{type: 'received'}, result.context]
@@ -4821,27 +6474,30 @@ export class Connection {
     callback: SignatureResultCallback,
     commitment?: Commitment,
   ): ClientSubscriptionId {
-    const clientSubscriptionId = this._makeSubscription({
-      callback: (notification, context) => {
-        if (notification.type === 'status') {
-          callback(notification.result, context);
-          // Signatures subscriptions are auto-removed by the RPC service
-          // so no need to explicitly send an unsubscribe message.
-          try {
-            this.removeSignatureListener(clientSubscriptionId);
-            // eslint-disable-next-line no-empty
-          } catch {
-            // Already removed.
+    const args = this._buildArgs(
+      [signature],
+      commitment || this._commitment || 'finalized', // Apply connection/server default.
+    );
+    const clientSubscriptionId = this._makeSubscription(
+      {
+        callback: (notification, context) => {
+          if (notification.type === 'status') {
+            callback(notification.result, context);
+            // Signatures subscriptions are auto-removed by the RPC service
+            // so no need to explicitly send an unsubscribe message.
+            try {
+              this.removeSignatureListener(clientSubscriptionId);
+              // eslint-disable-next-line no-empty
+            } catch (_err) {
+              // Already removed.
+            }
           }
-        }
-      },
-      method: 'signatureSubscribe',
-      params: {
-        options: {commitment},
-        signature,
+        },
+        method: 'signatureSubscribe',
+        unsubscribeMethod: 'signatureUnsubscribe',
       },
-      unsubscribeMethod: 'signatureUnsubscribe',
-    });
+      args,
+    );
     return clientSubscriptionId;
   }
 
@@ -4860,25 +6516,35 @@ export class Connection {
     callback: SignatureSubscriptionCallback,
     options?: SignatureSubscriptionOptions,
   ): ClientSubscriptionId {
-    const clientSubscriptionId = this._makeSubscription({
-      callback: (notification, context) => {
-        callback(notification, context);
-        // Signatures subscriptions are auto-removed by the RPC service
-        // so no need to explicitly send an unsubscribe message.
-        try {
-          this.removeSignatureListener(clientSubscriptionId);
-          // eslint-disable-next-line no-empty
-        } catch {
-          // Already removed.
-        }
-      },
-      method: 'signatureSubscribe',
-      params: {
-        options,
-        signature,
+    const {commitment, ...extra} = {
+      ...options,
+      commitment:
+        (options && options.commitment) || this._commitment || 'finalized', // Apply connection/server default.
+    };
+    const args = this._buildArgs(
+      [signature],
+      commitment,
+      undefined /* encoding */,
+      extra,
+    );
+    const clientSubscriptionId = this._makeSubscription(
+      {
+        callback: (notification, context) => {
+          callback(notification, context);
+          // Signatures subscriptions are auto-removed by the RPC service
+          // so no need to explicitly send an unsubscribe message.
+          try {
+            this.removeSignatureListener(clientSubscriptionId);
+            // eslint-disable-next-line no-empty
+          } catch (_err) {
+            // Already removed.
+          }
+        },
+        method: 'signatureSubscribe',
+        unsubscribeMethod: 'signatureUnsubscribe',
       },
-      unsubscribeMethod: 'signatureUnsubscribe',
-    });
+      args,
+    );
     return clientSubscriptionId;
   }
 
@@ -4901,7 +6567,7 @@ export class Connection {
    */
   _wsOnRootNotification(notification: Object) {
     const {result, subscription} = create(notification, RootNotificationResult);
-    this._publishNotification<RootChangeCallback>(subscription, [result]);
+    this._handleServerNotification<RootChangeCallback>(subscription, [result]);
   }
 
   /**
@@ -4911,12 +6577,14 @@ export class Connection {
    * @return subscription id
    */
   onRootChange(callback: RootChangeCallback): ClientSubscriptionId {
-    return this._makeSubscription({
-      callback,
-      method: 'rootSubscribe',
-      params: undefined,
-      unsubscribeMethod: 'rootUnsubscribe',
-    });
+    return this._makeSubscription(
+      {
+        callback,
+        method: 'rootSubscribe',
+        unsubscribeMethod: 'rootUnsubscribe',
+      },
+      [] /* args */,
+    );
   }
 
   /**