@solana/web3.js 1.77.2 → 1.78.0

package/lib/index.browser.esm.js

@@ -20,6 +20,10 @@ import { secp256k1 } from '@noble/curves/secp256k1';
  * Read more: https://blog.mozilla.org/warner/2011/11/29/ed25519-keys/
  */
 
+/**
+ * Ed25519 Keypair
+ */
+
 const generatePrivateKey = ed25519.utils.randomPrivateKey;
 const generateKeypair = () => {
   const privateScalar = ed25519.utils.randomPrivateKey();
@@ -102,6 +106,10 @@ const PUBLIC_KEY_LENGTH = 32;
  * Value to be converted into public key
  */
 
+/**
+ * JSON object representation of PublicKey class
+ */
+
 function isPublicKeyData(value) {
   return value._bn !== undefined;
 }
@@ -114,14 +122,13 @@ let uniquePublicKeyCounter = 1;
  */
 _Symbol$toStringTag = Symbol.toStringTag;
 class PublicKey extends Struct {
-  /** @internal */
-
   /**
    * Create a new PublicKey object
    * @param value ed25519 public key as buffer or base-58 encoded string
    */
   constructor(value) {
     super({});
+    /** @internal */
     this._bn = void 0;
     if (isPublicKeyData(value)) {
       this._bn = value._bn;
@@ -303,10 +310,6 @@ SOLANA_SCHEMA.set(PublicKey, {
  * @deprecated since v1.10.0, please use {@link Keypair} instead.
  */
 class Account {
-  /** @internal */
-
-  /** @internal */
-
   /**
    * Create a new Account object
    *
@@ -316,7 +319,9 @@ class Account {
    * @param secretKey Secret key for the account
    */
   constructor(secretKey) {
+    /** @internal */
     this._publicKey = void 0;
+    /** @internal */
     this._secretKey = void 0;
     if (secretKey) {
       const secretKeyBuffer = toBuffer(secretKey);
@@ -673,6 +678,10 @@ class CompiledKeys {
  * @property {string} data
  */
 
+/**
+ * Message constructor arguments
+ */
+
 /**
  * List of instructions to be processed atomically
  */
@@ -1117,17 +1126,17 @@ const VersionedMessage = {
  * Transaction signature as base-58 encoded string
  */
 
-let TransactionStatus;
-
-/**
- * Default (empty) signature
- */
-(function (TransactionStatus) {
+let TransactionStatus = /*#__PURE__*/function (TransactionStatus) {
   TransactionStatus[TransactionStatus["BLOCKHEIGHT_EXCEEDED"] = 0] = "BLOCKHEIGHT_EXCEEDED";
   TransactionStatus[TransactionStatus["PROCESSED"] = 1] = "PROCESSED";
   TransactionStatus[TransactionStatus["TIMED_OUT"] = 2] = "TIMED_OUT";
   TransactionStatus[TransactionStatus["NONCE_INVALID"] = 3] = "NONCE_INVALID";
-})(TransactionStatus || (TransactionStatus = {}));
+  return TransactionStatus;
+}({});
+
+/**
+ * Default (empty) signature
+ */
 const DEFAULT_SIGNATURE = Buffer.alloc(SIGNATURE_LENGTH_IN_BYTES).fill(0);
 
 /**
@@ -1135,25 +1144,34 @@ const DEFAULT_SIGNATURE = Buffer.alloc(SIGNATURE_LENGTH_IN_BYTES).fill(0);
  */
 
 /**
- * Transaction Instruction class
+ * List of TransactionInstruction object fields that may be initialized at construction
  */
-class TransactionInstruction {
-  /**
-   * Public keys to include in this transaction
-   * Boolean represents whether this pubkey needs to sign the transaction
-   */
 
-  /**
-   * Program Id to execute
-   */
+/**
+ * Configuration object for Transaction.serialize()
+ */
 
-  /**
-   * Program input
-   */
+/**
+ * @internal
+ */
 
+/**
+ * Transaction Instruction class
+ */
+class TransactionInstruction {
   constructor(opts) {
+    /**
+     * Public keys to include in this transaction
+     * Boolean represents whether this pubkey needs to sign the transaction
+     */
     this.keys = void 0;
+    /**
+     * Program Id to execute
+     */
     this.programId = void 0;
+    /**
+     * Program input
+     */
     this.data = Buffer.alloc(0);
     this.programId = opts.programId;
     this.keys = opts.keys;
@@ -1186,15 +1204,31 @@ class TransactionInstruction {
  * Pair of signature and corresponding public key
  */
 
+/**
+ * List of Transaction object fields that may be initialized at construction
+ */
+
+// For backward compatibility; an unfortunate consequence of being
+// forced to over-export types by the documentation generator.
+// See https://github.com/solana-labs/solana/pull/25820
+/**
+ * Blockhash-based transactions have a lifetime that are defined by
+ * the blockhash they include. Any transaction whose blockhash is
+ * too old will be rejected.
+ */
+/**
+ * Use these options to construct a durable nonce transaction.
+ */
+/**
+ * Nonce information to be used to build an offline Transaction.
+ */
+/**
+ * @internal
+ */
 /**
  * Transaction class
  */
 class Transaction {
-  /**
-   * Signatures for the transaction.  Typically created by invoking the
-   * `sign()` method
-   */
-
   /**
    * The first (payer) Transaction signature
    */
@@ -1209,18 +1243,57 @@ class Transaction {
    * The transaction fee payer
    */
 
+  // Construct a transaction with a blockhash and lastValidBlockHeight
+
+  // Construct a transaction using a durable nonce
+
+  /**
+   * @deprecated `TransactionCtorFields` has been deprecated and will be removed in a future version.
+   * Please supply a `TransactionBlockhashCtor` instead.
+   */
+
   /**
    * Construct an empty Transaction
    */
   constructor(opts) {
+    /**
+     * Signatures for the transaction.  Typically created by invoking the
+     * `sign()` method
+     */
     this.signatures = [];
     this.feePayer = void 0;
+    /**
+     * The instructions to atomically execute
+     */
     this.instructions = [];
+    /**
+     * A recent transaction id. Must be populated by the caller
+     */
     this.recentBlockhash = void 0;
+    /**
+     * the last block chain can advance to before tx is declared expired
+     * */
     this.lastValidBlockHeight = void 0;
+    /**
+     * Optional Nonce information. If populated, transaction will use a durable
+     * Nonce hash instead of a recentBlockhash. Must be populated by the caller
+     */
     this.nonceInfo = void 0;
+    /**
+     * If this is a nonce transaction this represents the minimum slot from which
+     * to evaluate if the nonce has advanced when attempting to confirm the
+     * transaction. This protects against a case where the transaction confirmation
+     * logic loads the nonce account from an old slot and assumes the mismatch in
+     * nonce value implies that the nonce has been advanced.
+     */
     this.minNonceContextSlot = void 0;
+    /**
+     * @internal
+     */
     this._message = void 0;
+    /**
+     * @internal
+     */
     this._json = void 0;
     if (!opts) {
       return;
@@ -2035,6 +2108,10 @@ function sleep(ms) {
   return new Promise(resolve => setTimeout(resolve, ms));
 }
 
+/**
+ * @internal
+ */
+
 /**
  * Populate a buffer of instruction data using an InstructionType
  * @internal
@@ -2154,6 +2231,62 @@ const u64 = bigInt(8);
  * Create account system transaction params
  */
 
+/**
+ * Transfer system transaction params
+ */
+
+/**
+ * Assign system transaction params
+ */
+
+/**
+ * Create account with seed system transaction params
+ */
+
+/**
+ * Create nonce account system transaction params
+ */
+
+/**
+ * Create nonce account with seed system transaction params
+ */
+
+/**
+ * Initialize nonce account system instruction params
+ */
+
+/**
+ * Advance nonce account system instruction params
+ */
+
+/**
+ * Withdraw nonce account system transaction params
+ */
+
+/**
+ * Authorize nonce account system transaction params
+ */
+
+/**
+ * Allocate account system transaction params
+ */
+
+/**
+ * Allocate account with seed system transaction params
+ */
+
+/**
+ * Assign account with seed system transaction params
+ */
+
+/**
+ * Transfer with seed system transaction params
+ */
+
+/** Decoded transfer system transaction instruction */
+
+/** Decoded transferWithSeed system transaction instruction */
+
 /**
  * System Instruction class
  */
@@ -3053,6 +3186,10 @@ class BpfLoader {
   }
 }
 
+function getDefaultExportFromCjs (x) {
+	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
+}
+
 var objToString = Object.prototype.toString;
 var objKeys = Object.keys || function(obj) {
 		var keys = [];
@@ -3127,7 +3264,7 @@ var fastStableStringify = function(val) {
 	}
 };
 
-var fastStableStringify$1 = fastStableStringify;
+var fastStableStringify$1 = /*@__PURE__*/getDefaultExportFromCjs(fastStableStringify);
 
 const MINIMUM_SLOT_PER_EPOCH = 32;
 
@@ -3160,21 +3297,16 @@ function nextPowerOfTwo(n) {
  * Can be retrieved with the {@link Connection.getEpochSchedule} method
  */
 class EpochSchedule {
-  /** The maximum number of slots in each epoch */
-
-  /** The number of slots before beginning of an epoch to calculate a leader schedule for that epoch */
-
-  /** Indicates whether epochs start short and grow */
-
-  /** The first epoch with `slotsPerEpoch` slots */
-
-  /** The first slot of `firstNormalEpoch` */
-
   constructor(slotsPerEpoch, leaderScheduleSlotOffset, warmup, firstNormalEpoch, firstNormalSlot) {
+    /** The maximum number of slots in each epoch */
     this.slotsPerEpoch = void 0;
+    /** The number of slots before beginning of an epoch to calculate a leader schedule for that epoch */
     this.leaderScheduleSlotOffset = void 0;
+    /** Indicates whether epochs start short and grow */
     this.warmup = void 0;
+    /** The first epoch with `slotsPerEpoch` slots */
     this.firstNormalEpoch = void 0;
+    /** The first slot of `firstNormalEpoch` */
     this.firstNormalSlot = void 0;
     this.slotsPerEpoch = slotsPerEpoch;
     this.leaderScheduleSlotOffset = leaderScheduleSlotOffset;
@@ -3397,6 +3529,92 @@ const BLOCKHASH_CACHE_TIMEOUT_MS = 30 * 1000;
  * https://gist.github.com/steveluscher/c057eca81d479ef705cdb53162f9971d
  */
 
+/** @internal */
+/** @internal */
+/** @internal */
+/** @internal */
+
+/** @internal */
+/**
+ * @internal
+ * Every subscription contains the args used to open the subscription with
+ * the server, and a list of callers interested in notifications.
+ */
+
+/**
+ * @internal
+ * A subscription may be in various states of connectedness. Only when it is
+ * fully connected will it have a server subscription id associated with it.
+ * This id can be returned to the server to unsubscribe the client entirely.
+ */
+
+/**
+ * A type that encapsulates a subscription's RPC method
+ * names and notification (callback) signature.
+ */
+
+/**
+ * @internal
+ * Utility type that keeps tagged unions intact while omitting properties.
+ */
+
+/**
+ * @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.
+ */
+
+/**
+ * @internal
+ */
+
+/**
+ * Extra contextual information for RPC responses
+ */
+
+/**
+ * Options for sending transactions
+ */
+
+/**
+ * Options for confirming transactions
+ */
+
+/**
+ * Options for getConfirmedSignaturesForAddress2
+ */
+
+/**
+ * Options for getSignaturesForAddress
+ */
+
+/**
+ * RPC Response with extra contextual information
+ */
+
+/**
+ * A strategy for confirming transactions that uses the last valid
+ * block height for a given blockhash to check for transaction expiration.
+ */
+
+/**
+ * A strategy for confirming durable nonce transactions.
+ */
+
+/**
+ * Properties shared by all transaction confirmation strategies
+ */
+
+/**
+ * This type represents all transaction confirmation strategies
+ */
+
 /* @internal */
 function assertEndpointUrl(putativeUrl) {
   if (/^https?:/.test(putativeUrl) === false) {
@@ -3515,6 +3733,85 @@ function versionedMessageFromResponse(version, response) {
  * </pre>
  */
 
+// Deprecated as of v1.5.5
+/**
+ * A subset of Commitment levels, which are at least optimistically confirmed
+ * <pre>
+ *   'confirmed': Query the most recent block which has reached 1 confirmation by the cluster
+ *   'finalized': Query the most recent block which has been finalized by the cluster
+ * </pre>
+ */
+/**
+ * Filter for largest accounts query
+ * <pre>
+ *   'circulating':    Return the largest accounts that are part of the circulating supply
+ *   'nonCirculating': Return the largest accounts that are not part of the circulating supply
+ * </pre>
+ */
+/**
+ * Configuration object for changing `getAccountInfo` query behavior
+ */
+/**
+ * Configuration object for changing `getBalance` query behavior
+ */
+/**
+ * Configuration object for changing `getBlock` query behavior
+ */
+/**
+ * Configuration object for changing `getBlock` query behavior
+ */
+/**
+ * Configuration object for changing `getStakeMinimumDelegation` query behavior
+ */
+/**
+ * Configuration object for changing `getBlockHeight` query behavior
+ */
+/**
+ * Configuration object for changing `getEpochInfo` query behavior
+ */
+/**
+ * Configuration object for changing `getInflationReward` query behavior
+ */
+/**
+ * Configuration object for changing `getLatestBlockhash` query behavior
+ */
+/**
+ * Configuration object for changing `isBlockhashValid` query behavior
+ */
+/**
+ * Configuration object for changing `getSlot` query behavior
+ */
+/**
+ * Configuration object for changing `getSlotLeader` query behavior
+ */
+/**
+ * Configuration object for changing `getTransaction` query behavior
+ */
+/**
+ * Configuration object for changing `getTransaction` query behavior
+ */
+/**
+ * Configuration object for changing `getLargestAccounts` query behavior
+ */
+/**
+ * Configuration object for changing `getSupply` request behavior
+ */
+/**
+ * Configuration object for changing query behavior
+ */
+/**
+ * Information describing a cluster node
+ */
+/**
+ * Information describing a vote account
+ */
+/**
+ * A collection of cluster vote accounts
+ */
+/**
+ * Network Inflation
+ * (see https://docs.solana.com/implemented-proposals/ed_overview)
+ */
 const GetInflationGovernorResult = type({
   foundation: number(),
   foundationTerm: number(),
@@ -3537,6 +3834,11 @@ const GetInflationRewardResult = jsonRpcResult(array(nullable(type({
   postBalance: number(),
   commission: optional(nullable(number()))
 }))));
+
+/**
+ * Configuration object for changing `getRecentPrioritizationFees` query behavior
+ */
+
 /**
  * Expected JSON RPC response for the "getRecentPrioritizationFees" message
  */
@@ -3622,6 +3924,127 @@ const SimulatedTransactionResponseStruct = jsonRpcResultAndContext(type({
     data: tuple([string(), literal('base64')])
   })))
 }));
+
+/**
+ * Metadata for a parsed confirmed transaction on the ledger
+ *
+ * @deprecated Deprecated since Solana v1.8.0. Please use {@link ParsedTransactionMeta} instead.
+ */
+
+/**
+ * Collection of addresses loaded by a transaction using address table lookups
+ */
+
+/**
+ * Metadata for a parsed transaction on the ledger
+ */
+
+/**
+ * Metadata for a confirmed transaction on the ledger
+ */
+
+/**
+ * A processed transaction from the RPC API
+ */
+
+/**
+ * A processed transaction from the RPC API
+ */
+
+/**
+ * A processed transaction message from the RPC API
+ */
+
+/**
+ * A confirmed transaction on the ledger
+ *
+ * @deprecated Deprecated since Solana v1.8.0.
+ */
+
+/**
+ * A partially decoded transaction instruction
+ */
+
+/**
+ * A parsed transaction message account
+ */
+
+/**
+ * A parsed transaction instruction
+ */
+
+/**
+ * A parsed address table lookup
+ */
+
+/**
+ * A parsed transaction message
+ */
+
+/**
+ * A parsed transaction
+ */
+
+/**
+ * A parsed and confirmed transaction on the ledger
+ *
+ * @deprecated Deprecated since Solana v1.8.0. Please use {@link ParsedTransactionWithMeta} instead.
+ */
+
+/**
+ * A parsed transaction on the ledger with meta
+ */
+
+/**
+ * A processed block fetched from the RPC API
+ */
+
+/**
+ * A processed block fetched from the RPC API where the `transactionDetails` mode is `accounts`
+ */
+
+/**
+ * A processed block fetched from the RPC API where the `transactionDetails` mode is `none`
+ */
+
+/**
+ * A block with parsed transactions
+ */
+
+/**
+ * A block with parsed transactions where the `transactionDetails` mode is `accounts`
+ */
+
+/**
+ * A block with parsed transactions where the `transactionDetails` mode is `none`
+ */
+
+/**
+ * A processed block fetched from the RPC API
+ */
+
+/**
+ * A processed block fetched from the RPC API where the `transactionDetails` mode is `accounts`
+ */
+
+/**
+ * A processed block fetched from the RPC API where the `transactionDetails` mode is `none`
+ */
+
+/**
+ * A confirmed block on the ledger
+ *
+ * @deprecated Deprecated since Solana v1.8.0.
+ */
+
+/**
+ * A Block on the ledger with signatures only
+ */
+
+/**
+ * recent block production information
+ */
+
 /**
  * Expected JSON RPC response for the "getBlockProduction" message
  */
@@ -4361,57 +4784,166 @@ const GetParsedTransactionRpcResult = jsonRpcResult(nullable(type({
 })));
 
 /**
- * Expected JSON RPC response for the "getRecentBlockhash" message
- *
- * @deprecated Deprecated since Solana v1.8.0. Please use {@link GetLatestBlockhashRpcResult} instead.
+ * Expected JSON RPC response for the "getRecentBlockhash" message
+ *
+ * @deprecated Deprecated since Solana v1.8.0. Please use {@link GetLatestBlockhashRpcResult} instead.
+ */
+const GetRecentBlockhashAndContextRpcResult = jsonRpcResultAndContext(type({
+  blockhash: string(),
+  feeCalculator: type({
+    lamportsPerSignature: number()
+  })
+}));
+
+/**
+ * Expected JSON RPC response for the "getLatestBlockhash" message
+ */
+const GetLatestBlockhashRpcResult = jsonRpcResultAndContext(type({
+  blockhash: string(),
+  lastValidBlockHeight: number()
+}));
+
+/**
+ * Expected JSON RPC response for the "isBlockhashValid" message
+ */
+const IsBlockhashValidRpcResult = jsonRpcResultAndContext(boolean());
+const PerfSampleResult = type({
+  slot: number(),
+  numTransactions: number(),
+  numSlots: number(),
+  samplePeriodSecs: number()
+});
+
+/*
+ * Expected JSON RPC response for "getRecentPerformanceSamples" message
+ */
+const GetRecentPerformanceSamplesRpcResult = jsonRpcResult(array(PerfSampleResult));
+
+/**
+ * Expected JSON RPC response for the "getFeeCalculatorForBlockhash" message
+ */
+const GetFeeCalculatorRpcResult = jsonRpcResultAndContext(nullable(type({
+  feeCalculator: type({
+    lamportsPerSignature: number()
+  })
+})));
+
+/**
+ * Expected JSON RPC response for the "requestAirdrop" message
+ */
+const RequestAirdropRpcResult = jsonRpcResult(string());
+
+/**
+ * Expected JSON RPC response for the "sendTransaction" message
+ */
+const SendTransactionRpcResult = jsonRpcResult(string());
+
+/**
+ * Information about the latest slot being processed by a node
+ */
+
+/**
+ * Parsed account data
+ */
+
+/**
+ * Stake Activation data
+ */
+
+/**
+ * Data slice argument for getProgramAccounts
+ */
+
+/**
+ * Memory comparison filter for getProgramAccounts
+ */
+
+/**
+ * Data size comparison filter for getProgramAccounts
+ */
+
+/**
+ * A filter object for getProgramAccounts
+ */
+
+/**
+ * Configuration object for getProgramAccounts requests
+ */
+
+/**
+ * Configuration object for getParsedProgramAccounts
+ */
+
+/**
+ * Configuration object for getMultipleAccounts
+ */
+
+/**
+ * Configuration object for `getStakeActivation`
+ */
+
+/**
+ * Configuration object for `getStakeActivation`
+ */
+
+/**
+ * Configuration object for `getStakeActivation`
+ */
+
+/**
+ * Configuration object for `getNonce`
+ */
+
+/**
+ * Configuration object for `getNonceAndContext`
+ */
+
+/**
+ * Information describing an account
+ */
+
+/**
+ * Account information identified by pubkey
+ */
+
+/**
+ * Callback function for account change notifications
+ */
+
+/**
+ * Callback function for program account change notifications
+ */
+
+/**
+ * Callback function for slot change notifications
+ */
+
+/**
+ * Callback function for slot update notifications
  */
-const GetRecentBlockhashAndContextRpcResult = jsonRpcResultAndContext(type({
-  blockhash: string(),
-  feeCalculator: type({
-    lamportsPerSignature: number()
-  })
-}));
 
 /**
- * Expected JSON RPC response for the "getLatestBlockhash" message
+ * Callback function for signature status notifications
  */
-const GetLatestBlockhashRpcResult = jsonRpcResultAndContext(type({
-  blockhash: string(),
-  lastValidBlockHeight: number()
-}));
-const PerfSampleResult = type({
-  slot: number(),
-  numTransactions: number(),
-  numSlots: number(),
-  samplePeriodSecs: number()
-});
 
-/*
- * Expected JSON RPC response for "getRecentPerformanceSamples" message
+/**
+ * Signature status notification with transaction result
  */
-const GetRecentPerformanceSamplesRpcResult = jsonRpcResult(array(PerfSampleResult));
 
 /**
- * Expected JSON RPC response for the "getFeeCalculatorForBlockhash" message
+ * Signature received notification
  */
-const GetFeeCalculatorRpcResult = jsonRpcResultAndContext(nullable(type({
-  feeCalculator: type({
-    lamportsPerSignature: number()
-  })
-})));
 
 /**
- * Expected JSON RPC response for the "requestAirdrop" message
+ * Callback function for signature notifications
  */
-const RequestAirdropRpcResult = jsonRpcResult(string());
 
 /**
- * Expected JSON RPC response for the "sendTransaction" message
+ * Signature subscription options
  */
-const SendTransactionRpcResult = jsonRpcResult(string());
 
 /**
- * Information about the latest slot being processed by a node
+ * Callback function for root change notifications
  */
 
 /**
@@ -4439,66 +4971,60 @@ const LogsNotificationResult = type({
  * Filter for log subscriptions.
  */
 
-/** @internal */
-const COMMON_HTTP_HEADERS = {
-  'solana-client': `js/${"0.0.0-development" }`
-};
+/**
+ * Callback function for log notifications.
+ */
 
 /**
- * A connection to a fullnode JSON RPC endpoint
+ * Signature result
  */
-class Connection {
-  /** @internal */
-  /** @internal */
-  /** @internal */
-  /** @internal */
-  /** @internal */
-  /** @internal */
-  /** @internal */
-  /** @internal */
-  /** @internal */
-  /** @internal */
 
-  /** @internal */
+/**
+ * Transaction error
+ */
 
-  /** @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.
-   *
-   */
+/**
+ * Transaction confirmation status
+ * <pre>
+ *   'processed': Transaction landed in a block which has reached 1 confirmation by the connected node
+ *   'confirmed': Transaction landed in a block which has reached 1 confirmation by the cluster
+ *   'finalized': Transaction landed in a block which has been finalized by the cluster
+ * </pre>
+ */
 
-  /** @internal */
-  /** @internal */
-  /** @internal */
+/**
+ * Signature status
+ */
 
-  /** @internal */
-  /** @internal */
+/**
+ * A confirmed signature with its status
+ */
 
-  /** @internal */
+/**
+ * An object defining headers to be passed to the RPC server
+ */
 
-  /** @internal */
+/**
+ * The type of the JavaScript `fetch()` API
+ */
 
-  /** @internal */
+/**
+ * A callback used to augment the outgoing HTTP request
+ */
 
-  /** @internal */
+/**
+ * Configuration for instantiating a Connection
+ */
 
-  /**
-   * Special case.
-   * After a signature is processed, RPCs automatically dispose of the
-   * subscription on the server side. We need to track which of these
-   * subscriptions have been disposed in such a way, so that we know
-   * whether the client is dealing with a not-yet-processed signature
-   * (in which case we must tear down the server subscription) or an
-   * already-processed signature (in which case the client can simply
-   * clear out the subscription locally without telling the server).
-   *
-   * NOTE: There is a proposal to eliminate this special case, here:
-   * https://github.com/solana-labs/solana/issues/18892
-   */
-  /** @internal */
+/** @internal */
+const COMMON_HTTP_HEADERS = {
+  'solana-client': `js/${"0.0.0-development" }`
+};
 
+/**
+ * A connection to a fullnode JSON RPC endpoint
+ */
+class Connection {
   /**
    * Establish a JSON RPC connection
    *
@@ -4506,33 +5032,77 @@ class Connection {
    * @param commitmentOrConfig optional default commitment level or optional ConnectionConfig configuration object
    */
   constructor(endpoint, _commitmentOrConfig) {
+    /** @internal */
     this._commitment = void 0;
+    /** @internal */
     this._confirmTransactionInitialTimeout = void 0;
+    /** @internal */
     this._rpcEndpoint = void 0;
+    /** @internal */
     this._rpcWsEndpoint = void 0;
+    /** @internal */
     this._rpcClient = void 0;
+    /** @internal */
     this._rpcRequest = void 0;
+    /** @internal */
     this._rpcBatchRequest = void 0;
+    /** @internal */
     this._rpcWebSocket = void 0;
+    /** @internal */
     this._rpcWebSocketConnected = false;
+    /** @internal */
     this._rpcWebSocketHeartbeat = null;
+    /** @internal */
     this._rpcWebSocketIdleTimeout = 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.
+     *
+     */
     this._rpcWebSocketGeneration = 0;
+    /** @internal */
     this._disableBlockhashCaching = false;
+    /** @internal */
     this._pollingBlockhash = false;
+    /** @internal */
     this._blockhashInfo = {
       latestBlockhash: null,
       lastFetch: 0,
       transactionSignatures: [],
       simulatedSignatures: []
     };
+    /** @internal */
     this._nextClientSubscriptionId = 0;
+    /** @internal */
     this._subscriptionDisposeFunctionsByClientSubscriptionId = {};
+    /** @internal */
     this._subscriptionHashByClientSubscriptionId = {};
+    /** @internal */
     this._subscriptionStateChangeCallbacksByHash = {};
+    /** @internal */
     this._subscriptionCallbacksByServerSubscriptionId = {};
+    /** @internal */
     this._subscriptionsByHash = {};
+    /**
+     * Special case.
+     * After a signature is processed, RPCs automatically dispose of the
+     * subscription on the server side. We need to track which of these
+     * subscriptions have been disposed in such a way, so that we know
+     * whether the client is dealing with a not-yet-processed signature
+     * (in which case we must tear down the server subscription) or an
+     * already-processed signature (in which case the client can simply
+     * clear out the subscription locally without telling the server).
+     *
+     * NOTE: There is a proposal to eliminate this special case, here:
+     * https://github.com/solana-labs/solana/issues/18892
+     */
+    /** @internal */
     this._subscriptionsAutoDisposedByRpc = new Set();
+    /*
+     * Returns the current block height of the node
+     */
     this.getBlockHeight = (() => {
       const requestPromises = {};
       return async commitmentOrConfig => {
@@ -4928,6 +5498,8 @@ class Connection {
    * @return {Promise<Array<{pubkey: PublicKey, account: AccountInfo<Buffer>}>>}
    */
 
+  // eslint-disable-next-line no-dupe-class-members
+
   // eslint-disable-next-line no-dupe-class-members
   async getProgramAccounts(programId, configOrCommitment) {
     const {
@@ -4966,6 +5538,8 @@ class Connection {
     }
     return res.result;
   }
+
+  /** @deprecated Instead, call `confirmTransaction` and pass in {@link TransactionConfirmationStrategy} */ // eslint-disable-next-line no-dupe-class-members
   // eslint-disable-next-line no-dupe-class-members
   async confirmTransaction(strategy, commitment) {
     let rawSignature;
@@ -5709,6 +6283,23 @@ class Connection {
     return res.result;
   }
 
+  /**
+   * Returns whether a blockhash is still valid or not
+   */
+  async isBlockhashValid(blockhash, rawConfig) {
+    const {
+      commitment,
+      config
+    } = extractCommitmentFromConfig(rawConfig);
+    const args = this._buildArgs([blockhash], commitment, undefined /* encoding */, config);
+    const unsafeRes = await this._rpcRequest('isBlockhashValid', args);
+    const res = create(unsafeRes, IsBlockhashValidRpcResult);
+    if ('error' in res) {
+      throw new SolanaJSONRPCError(res.error, 'failed to determine if the blockhash `' + blockhash + '`is valid');
+    }
+    return res.result;
+  }
+
   /**
    * Fetch the node version
    */
@@ -5740,10 +6331,24 @@ class Connection {
    * setting the `maxSupportedTransactionVersion` property.
    */
 
+  /**
+   * @deprecated Instead, call `getBlock` using a `GetVersionedBlockConfig` by
+   * setting the `maxSupportedTransactionVersion` property.
+   */ // eslint-disable-next-line no-dupe-class-members
+  /**
+   * @deprecated Instead, call `getBlock` using a `GetVersionedBlockConfig` by
+   * setting the `maxSupportedTransactionVersion` property.
+   */
+  // eslint-disable-next-line no-dupe-class-members
   /**
    * Fetch a processed block from the cluster.
    */
   // eslint-disable-next-line no-dupe-class-members
+  // eslint-disable-next-line no-dupe-class-members
+  // eslint-disable-next-line no-dupe-class-members
+  /**
+   * Fetch a processed block from the cluster.
+   */ // eslint-disable-next-line no-dupe-class-members
   async getBlock(slot, rawConfig) {
     const {
       commitment,
@@ -5804,6 +6409,10 @@ class Connection {
    * Fetch parsed transaction details for a confirmed or finalized block
    */
 
+  // eslint-disable-next-line no-dupe-class-members
+
+  // eslint-disable-next-line no-dupe-class-members
+
   // eslint-disable-next-line no-dupe-class-members
   async getParsedBlock(slot, rawConfig) {
     const {
@@ -5843,11 +6452,6 @@ class Connection {
       throw new SolanaJSONRPCError(e, 'failed to get block');
     }
   }
-
-  /*
-   * Returns the current block height of the node
-   */
-
   /*
    * Returns recent block production information from the current or previous epoch
    */
@@ -5883,8 +6487,10 @@ class Connection {
 
   /**
    * Fetch a confirmed or finalized transaction from the cluster.
-   */
-  // eslint-disable-next-line no-dupe-class-members
+   */ // eslint-disable-next-line no-dupe-class-members
+  /**
+   * Fetch a confirmed or finalized transaction from the cluster.
+   */ // eslint-disable-next-line no-dupe-class-members
   async getTransaction(signature, rawConfig) {
     const {
       commitment,
@@ -5963,8 +6569,12 @@ class Connection {
    * 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
+   */ // eslint-disable-next-line no-dupe-class-members
+  /**
+   * 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, commitmentOrConfig) {
     const {
       commitment,
@@ -6390,8 +7000,10 @@ class Connection {
 
   /**
    * Simulate a transaction
-   */
-  // eslint-disable-next-line no-dupe-class-members
+   */ // eslint-disable-next-line no-dupe-class-members
+  /**
+   * Simulate a transaction
+   */ // eslint-disable-next-line no-dupe-class-members
   async simulateTransaction(transactionOrMessage, configOrSigners, includeAccounts) {
     if ('message' in transactionOrMessage) {
       const versionedTx = transactionOrMessage;
@@ -6502,10 +7114,12 @@ class Connection {
    * VersionedTransaction}
    */
 
+  /**
+   * Send a signed transaction
+   */ // eslint-disable-next-line no-dupe-class-members
   /**
    * Sign and send a transaction
-   */
-  // eslint-disable-next-line no-dupe-class-members
+   */ // eslint-disable-next-line no-dupe-class-members
   async sendTransaction(transaction, signersOrOptions, options) {
     if ('version' in transaction) {
       if (signersOrOptions && Array.isArray(signersOrOptions)) {
@@ -6913,7 +7527,7 @@ class Connection {
    */
   args) {
     const clientSubscriptionId = this._nextClientSubscriptionId++;
-    const hash = fastStableStringify$1([subscriptionConfig.method, args]);
+    const hash = fastStableStringify$1([subscriptionConfig.method, args], true /* isArrayProp */);
 
     const existingSubscription = this._subscriptionsByHash[hash];
     if (existingSubscription === undefined) {
@@ -7395,6 +8009,10 @@ class Keypair {
   }
 }
 
+/**
+ * An enumeration of valid LookupTableInstructionType's
+ */
+
 /**
  * An enumeration of valid address lookup table InstructionType's
  * @internal
@@ -7736,6 +8354,22 @@ class ComputeBudgetInstruction {
  * An enumeration of valid ComputeBudgetInstructionType's
  */
 
+/**
+ * Request units instruction params
+ */
+
+/**
+ * Request heap frame instruction params
+ */
+
+/**
+ * Set compute unit limit instruction params
+ */
+
+/**
+ * Set compute unit price instruction params
+ */
+
 /**
  * An enumeration of valid ComputeBudget InstructionType's
  * @internal
@@ -7824,6 +8458,10 @@ const SIGNATURE_BYTES = 64;
  * Params for creating an ed25519 instruction using a public key
  */
 
+/**
+ * Params for creating an ed25519 instruction using a private key
+ */
+
 const ED25519_INSTRUCTION_LAYOUT = BufferLayout.struct([BufferLayout.u8('numSignatures'), BufferLayout.u8('padding'), BufferLayout.u16('signatureOffset'), BufferLayout.u16('signatureInstructionIndex'), BufferLayout.u16('publicKeyOffset'), BufferLayout.u16('publicKeyInstructionIndex'), BufferLayout.u16('messageDataOffset'), BufferLayout.u16('messageDataSize'), BufferLayout.u16('messageInstructionIndex')]);
 class Ed25519Program {
   /**
@@ -7921,6 +8559,14 @@ const SIGNATURE_OFFSETS_SERIALIZED_SIZE = 11;
  * Params for creating an secp256k1 instruction using a public key
  */
 
+/**
+ * Params for creating an secp256k1 instruction using an Ethereum address
+ */
+
+/**
+ * Params for creating an secp256k1 instruction using a private key
+ */
+
 const SECP256K1_INSTRUCTION_LAYOUT = BufferLayout.struct([BufferLayout.u8('numSignatures'), BufferLayout.u16('signatureOffset'), BufferLayout.u8('signatureInstructionIndex'), BufferLayout.u16('ethAddressOffset'), BufferLayout.u8('ethAddressInstructionIndex'), BufferLayout.u16('messageDataOffset'), BufferLayout.u16('messageDataSize'), BufferLayout.u8('messageInstructionIndex'), BufferLayout.blob(20, 'ethAddress'), BufferLayout.blob(64, 'signature'), BufferLayout.u8('recoveryId')]);
 class Secp256k1Program {
   /**
@@ -8056,17 +8702,15 @@ const STAKE_CONFIG_ID = new PublicKey('StakeConfig111111111111111111111111111111
  * Stake account authority info
  */
 class Authorized {
-  /** stake authority */
-
-  /** withdraw authority */
-
   /**
    * Create a new Authorized object
    * @param staker the stake authority
    * @param withdrawer the withdraw authority
    */
   constructor(staker, withdrawer) {
+    /** stake authority */
     this.staker = void 0;
+    /** withdraw authority */
     this.withdrawer = void 0;
     this.staker = staker;
     this.withdrawer = withdrawer;
@@ -8076,18 +8720,15 @@ class Authorized {
  * Stake account lockup info
  */
 class Lockup {
-  /** Unix timestamp of lockup expiration */
-
-  /** Epoch of lockup expiration */
-
-  /** Lockup custodian authority */
-
   /**
    * Create a new Lockup object
    */
   constructor(unixTimestamp, epoch, custodian) {
+    /** Unix timestamp of lockup expiration */
     this.unixTimestamp = void 0;
+    /** Epoch of lockup expiration */
     this.epoch = void 0;
+    /** Lockup custodian authority */
     this.custodian = void 0;
     this.unixTimestamp = unixTimestamp;
     this.epoch = epoch;
@@ -8099,6 +8740,39 @@ class Lockup {
    */
 }
 Lockup.default = new Lockup(0, 0, PublicKey.default);
+/**
+ * Create stake account transaction params
+ */
+/**
+ * Create stake account with seed transaction params
+ */
+/**
+ * Initialize stake instruction params
+ */
+/**
+ * Delegate stake instruction params
+ */
+/**
+ * Authorize stake instruction params
+ */
+/**
+ * Authorize stake instruction params using a derived key
+ */
+/**
+ * Split stake instruction params
+ */
+/**
+ * Split with seed transaction params
+ */
+/**
+ * Withdraw stake instruction params
+ */
+/**
+ * Deactivate stake instruction params
+ */
+/**
+ * Merge stake instruction params
+ */
 /**
  * Stake Instruction class
  */
@@ -8787,6 +9461,13 @@ class StakeProgram {
   }
 }
 StakeProgram.programId = new PublicKey('Stake11111111111111111111111111111111111111');
+/**
+ * Max space of a Stake account
+ *
+ * This is generated from the solana-stake-program StakeState struct as
+ * `StakeState::size_of()`:
+ * https://docs.rs/solana-stake-program/latest/solana_stake_program/stake_state/enum.StakeState.html
+ */
 StakeProgram.space = 200;
 
 /**
@@ -8811,6 +9492,22 @@ class VoteInit {
  * Create vote account transaction params
  */
 
+/**
+ * InitializeAccount instruction params
+ */
+
+/**
+ * Authorize instruction params
+ */
+
+/**
+ * AuthorizeWithSeed instruction params
+ */
+
+/**
+ * Withdraw from vote account transaction params
+ */
+
 /**
  * Vote Instruction class
  */
@@ -8942,6 +9639,8 @@ class VoteInstruction {
  * An enumeration of valid VoteInstructionType's
  */
 
+/** @internal */
+
 const VOTE_INSTRUCTION_LAYOUTS = Object.freeze({
   InitializeAccount: {
     index: 0,
@@ -9178,6 +9877,15 @@ class VoteProgram {
   }
 }
 VoteProgram.programId = new PublicKey('Vote111111111111111111111111111111111111111');
+/**
+ * Max space of a Vote account
+ *
+ * This is generated from the solana-vote-program VoteState struct as
+ * `VoteState::size_of()`:
+ * https://docs.rs/solana-vote-program/1.9.5/solana_vote_program/vote_state/struct.VoteState.html#method.size_of
+ *
+ * KEEP IN SYNC WITH `VoteState::size_of()` in https://github.com/solana-labs/solana/blob/a474cb24b9238f5edcc982f65c0b37d4a1046f7e/sdk/program/src/vote/state/mod.rs#L340-L342
+ */
 VoteProgram.space = 3731;
 
 const VALIDATOR_INFO_KEY = new PublicKey('Va1idator1nfo111111111111111111111111111111');
@@ -9186,6 +9894,10 @@ const VALIDATOR_INFO_KEY = new PublicKey('Va1idator1nfo1111111111111111111111111
  * @internal
  */
 
+/**
+ * Info used to identity validators.
+ */
+
 const InfoString = type({
   name: string(),
   website: optional(string()),
@@ -9197,14 +9909,6 @@ const InfoString = type({
  * ValidatorInfo class
  */
 class ValidatorInfo {
-  /**
-   * validator public key
-   */
-
-  /**
-   * validator information
-   */
-
   /**
    * Construct a valid ValidatorInfo
    *
@@ -9212,7 +9916,13 @@ class ValidatorInfo {
    * @param info validator information
    */
   constructor(key, info) {
+    /**
+     * validator public key
+     */
     this.key = void 0;
+    /**
+     * validator information
+     */
     this.info = void 0;
     this.key = key;
     this.info = info;
@@ -9253,6 +9963,11 @@ class ValidatorInfo {
 }
 
 const VOTE_PROGRAM_ID = new PublicKey('Vote111111111111111111111111111111111111111');
+
+/**
+ * History of how many credits earned by the end of each epoch
+ */
+
 /**
  * See https://github.com/solana-labs/solana/blob/8a12ed029cfa38d4a45400916c2463fb82bbec8c/programs/vote_api/src/vote_state.rs#L68-L88
  *
@@ -9392,9 +10107,7 @@ function clusterApiUrl(cluster, tls) {
 /**
  * @deprecated Calling `sendAndConfirmRawTransaction()` without a `confirmationStrategy`
  * is no longer supported and will be removed in a future version.
- */
-// eslint-disable-next-line no-redeclare
-
+ */ // eslint-disable-next-line no-redeclare
 // eslint-disable-next-line no-redeclare
 async function sendAndConfirmRawTransaction(connection, rawTransaction, confirmationStrategyOrConfirmOptions, maybeConfirmOptions) {
   let confirmationStrategy;