@solana/web3.js 1.77.2 → 1.78.0

package/lib/index.cjs.js

@@ -62,6 +62,10 @@ var WebsocketFactory__default = /*#__PURE__*/_interopDefaultCompat(WebsocketFact
  * Read more: https://blog.mozilla.org/warner/2011/11/29/ed25519-keys/
  */
 
+/**
+ * Ed25519 Keypair
+ */
+
 const generatePrivateKey = ed25519.ed25519.utils.randomPrivateKey;
 const generateKeypair = () => {
   const privateScalar = ed25519.ed25519.utils.randomPrivateKey();
@@ -144,6 +148,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;
 }
@@ -156,14 +164,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;
@@ -345,10 +352,6 @@ SOLANA_SCHEMA.set(PublicKey, {
  * @deprecated since v1.10.0, please use {@link Keypair} instead.
  */
 class Account {
-  /** @internal */
-
-  /** @internal */
-
   /**
    * Create a new Account object
    *
@@ -358,7 +361,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);
@@ -715,6 +720,10 @@ class CompiledKeys {
  * @property {string} data
  */
 
+/**
+ * Message constructor arguments
+ */
+
 /**
  * List of instructions to be processed atomically
  */
@@ -1159,17 +1168,17 @@ const VersionedMessage = {
  * Transaction signature as base-58 encoded string
  */
 
-exports.TransactionStatus = void 0;
-
-/**
- * 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";
-})(exports.TransactionStatus || (exports.TransactionStatus = {}));
+  return TransactionStatus;
+}({});
+
+/**
+ * Default (empty) signature
+ */
 const DEFAULT_SIGNATURE = buffer.Buffer.alloc(SIGNATURE_LENGTH_IN_BYTES).fill(0);
 
 /**
@@ -1177,25 +1186,34 @@ const DEFAULT_SIGNATURE = buffer.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.Buffer.alloc(0);
     this.programId = opts.programId;
     this.keys = opts.keys;
@@ -1228,15 +1246,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
    */
@@ -1251,18 +1285,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;
@@ -2077,6 +2150,10 @@ function sleep(ms) {
   return new Promise(resolve => setTimeout(resolve, ms));
 }
 
+/**
+ * @internal
+ */
+
 /**
  * Populate a buffer of instruction data using an InstructionType
  * @internal
@@ -2196,6 +2273,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
  */
@@ -3099,11 +3232,7 @@ function getDefaultExportFromCjs (x) {
 	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
 }
 
-var agentkeepaliveExports = {};
-var agentkeepalive = {
-  get exports(){ return agentkeepaliveExports; },
-  set exports(v){ agentkeepaliveExports = v; },
-};
+var agentkeepalive = {exports: {}};
 
 /**
  * Helpers.
@@ -3291,17 +3420,9 @@ var humanizeMs = function (t) {
   return r;
 };
 
-var srcExports = {};
-var src = {
-  get exports(){ return srcExports; },
-  set exports(v){ srcExports = v; },
-};
+var src = {exports: {}};
 
-var browserExports = {};
-var browser$1 = {
-  get exports(){ return browserExports; },
-  set exports(v){ browserExports = v; },
-};
+var browser$1 = {exports: {}};
 
 /**
  * Helpers.
@@ -3761,7 +3882,7 @@ function requireCommon () {
 var hasRequiredBrowser$1;
 
 function requireBrowser$1 () {
-	if (hasRequiredBrowser$1) return browserExports;
+	if (hasRequiredBrowser$1) return browser$1.exports;
 	hasRequiredBrowser$1 = 1;
 	(function (module, exports) {
 		/**
@@ -4030,16 +4151,12 @@ function requireBrowser$1 () {
 			} catch (error) {
 				return '[UnexpectedJSONParseError]: ' + error.message;
 			}
-		};
-} (browser$1, browserExports));
-	return browserExports;
+		}; 
+	} (browser$1, browser$1.exports));
+	return browser$1.exports;
 }
 
-var nodeExports = {};
-var node = {
-  get exports(){ return nodeExports; },
-  set exports(v){ nodeExports = v; },
-};
+var node = {exports: {}};
 
 /* eslint-env browser */
 
@@ -4081,7 +4198,7 @@ function requireBrowser () {
 var hasRequiredNode;
 
 function requireNode () {
-	if (hasRequiredNode) return nodeExports;
+	if (hasRequiredNode) return node.exports;
 	hasRequiredNode = 1;
 	(function (module, exports) {
 		const tty = require$$0__default$1.default;
@@ -4342,9 +4459,9 @@ function requireNode () {
 		formatters.O = function (v) {
 			this.inspectOpts.colors = this.useColors;
 			return util.inspect(v, this.inspectOpts);
-		};
-} (node, nodeExports));
-	return nodeExports;
+		}; 
+	} (node, node.exports));
+	return node.exports;
 }
 
 /**
@@ -4352,19 +4469,15 @@ function requireNode () {
  * treat as a browser.
  */
 
-(function (module) {
-	if (typeof process === 'undefined' || process.type === 'renderer' || process.browser === true || process.__nwjs) {
-		module.exports = requireBrowser$1();
-	} else {
-		module.exports = requireNode();
-	}
-} (src));
+if (typeof process === 'undefined' || process.type === 'renderer' || process.browser === true || process.__nwjs) {
+	src.exports = requireBrowser$1();
+} else {
+	src.exports = requireNode();
+}
 
-var compatExports = {};
-var compat = {
-  get exports(){ return compatExports; },
-  set exports(v){ compatExports = v; },
-};
+var srcExports = src.exports;
+
+var compat = {exports: {}};
 
 /*!
  * depd
@@ -4585,9 +4698,11 @@ function requireEventListenerCount () {
 
 	function toString (obj) {
 	  return obj.toString()
-	}
+	} 
 } (compat));
 
+var compatExports = compat.exports;
+
 /*!
  * depd
  * Copyright(c) 2014-2017 Douglas Christopher Wilson
@@ -5527,7 +5642,7 @@ const {
   CREATE_HTTPS_CONNECTION,
 } = constants;
 
-class HttpsAgent extends HttpAgent {
+let HttpsAgent$1 = class HttpsAgent extends HttpAgent {
   constructor(options) {
     super(options);
 
@@ -5550,10 +5665,10 @@ class HttpsAgent extends HttpAgent {
     this[INIT_SOCKET](socket, options);
     return socket;
   }
-}
+};
 
 // https://github.com/nodejs/node/blob/master/lib/https.js#L89
-HttpsAgent.prototype[CREATE_HTTPS_CONNECTION] = OriginalHttpsAgent.prototype.createConnection;
+HttpsAgent$1.prototype[CREATE_HTTPS_CONNECTION] = OriginalHttpsAgent.prototype.createConnection;
 
 [
   'getName',
@@ -5564,19 +5679,17 @@ HttpsAgent.prototype[CREATE_HTTPS_CONNECTION] = OriginalHttpsAgent.prototype.cre
 ].forEach(function(method) {
   /* istanbul ignore next */
   if (typeof OriginalHttpsAgent.prototype[method] === 'function') {
-    HttpsAgent.prototype[method] = OriginalHttpsAgent.prototype[method];
+    HttpsAgent$1.prototype[method] = OriginalHttpsAgent.prototype[method];
   }
 });
 
-var https_agent = HttpsAgent;
-
-(function (module) {
+var https_agent = HttpsAgent$1;
 
-	module.exports = agent;
-	module.exports.HttpsAgent = https_agent;
-	module.exports.constants = constants;
-} (agentkeepalive));
+agentkeepalive.exports = agent;
+var HttpsAgent = agentkeepalive.exports.HttpsAgent = https_agent;
+agentkeepalive.exports.constants = constants;
 
+var agentkeepaliveExports = agentkeepalive.exports;
 var HttpKeepAliveAgent = /*@__PURE__*/getDefaultExportFromCjs(agentkeepaliveExports);
 
 var objToString = Object.prototype.toString;
@@ -5653,7 +5766,7 @@ var fastStableStringify = function(val) {
 	}
 };
 
-var fastStableStringify$1 = fastStableStringify;
+var fastStableStringify$1 = /*@__PURE__*/getDefaultExportFromCjs(fastStableStringify);
 
 const MINIMUM_SLOT_PER_EPOCH = 32;
 
@@ -5686,21 +5799,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;
@@ -5926,6 +6034,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) {
@@ -6044,53 +6238,137 @@ function versionedMessageFromResponse(version, response) {
  * </pre>
  */
 
-const GetInflationGovernorResult = superstruct.type({
-  foundation: superstruct.number(),
-  foundationTerm: superstruct.number(),
-  initial: superstruct.number(),
-  taper: superstruct.number(),
-  terminal: superstruct.number()
-});
-
+// Deprecated as of v1.5.5
 /**
- * The inflation reward for an epoch
+ * 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>
  */
-
 /**
- * Expected JSON RPC response for the "getInflationReward" message
+ * 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>
  */
-const GetInflationRewardResult = jsonRpcResult(superstruct.array(superstruct.nullable(superstruct.type({
-  epoch: superstruct.number(),
-  effectiveSlot: superstruct.number(),
-  amount: superstruct.number(),
-  postBalance: superstruct.number(),
-  commission: superstruct.optional(superstruct.nullable(superstruct.number()))
-}))));
 /**
- * Expected JSON RPC response for the "getRecentPrioritizationFees" message
+ * Configuration object for changing `getAccountInfo` query behavior
  */
-const GetRecentPrioritizationFeesResult = superstruct.array(superstruct.type({
-  slot: superstruct.number(),
-  prioritizationFee: superstruct.number()
-}));
 /**
- * Expected JSON RPC response for the "getInflationRate" message
+ * Configuration object for changing `getBalance` query behavior
  */
-const GetInflationRateResult = superstruct.type({
-  total: superstruct.number(),
-  validator: superstruct.number(),
-  foundation: superstruct.number(),
-  epoch: superstruct.number()
-});
-
 /**
- * Information about the current epoch
+ * Configuration object for changing `getBlock` query behavior
  */
-
-const GetEpochInfoResult = superstruct.type({
-  epoch: superstruct.number(),
-  slotIndex: superstruct.number(),
-  slotsInEpoch: superstruct.number(),
+/**
+ * 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 = superstruct.type({
+  foundation: superstruct.number(),
+  foundationTerm: superstruct.number(),
+  initial: superstruct.number(),
+  taper: superstruct.number(),
+  terminal: superstruct.number()
+});
+
+/**
+ * The inflation reward for an epoch
+ */
+
+/**
+ * Expected JSON RPC response for the "getInflationReward" message
+ */
+const GetInflationRewardResult = jsonRpcResult(superstruct.array(superstruct.nullable(superstruct.type({
+  epoch: superstruct.number(),
+  effectiveSlot: superstruct.number(),
+  amount: superstruct.number(),
+  postBalance: superstruct.number(),
+  commission: superstruct.optional(superstruct.nullable(superstruct.number()))
+}))));
+
+/**
+ * Configuration object for changing `getRecentPrioritizationFees` query behavior
+ */
+
+/**
+ * Expected JSON RPC response for the "getRecentPrioritizationFees" message
+ */
+const GetRecentPrioritizationFeesResult = superstruct.array(superstruct.type({
+  slot: superstruct.number(),
+  prioritizationFee: superstruct.number()
+}));
+/**
+ * Expected JSON RPC response for the "getInflationRate" message
+ */
+const GetInflationRateResult = superstruct.type({
+  total: superstruct.number(),
+  validator: superstruct.number(),
+  foundation: superstruct.number(),
+  epoch: superstruct.number()
+});
+
+/**
+ * Information about the current epoch
+ */
+
+const GetEpochInfoResult = superstruct.type({
+  epoch: superstruct.number(),
+  slotIndex: superstruct.number(),
+  slotsInEpoch: superstruct.number(),
   absoluteSlot: superstruct.number(),
   blockHeight: superstruct.optional(superstruct.number()),
   transactionCount: superstruct.optional(superstruct.number())
@@ -6151,6 +6429,127 @@ const SimulatedTransactionResponseStruct = jsonRpcResultAndContext(superstruct.t
     data: superstruct.tuple([superstruct.string(), superstruct.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
  */
@@ -6180,7 +6579,7 @@ function createRpcClient(url, httpHeaders, customFetch, fetchMiddleware, disable
           maxSockets: 25
         };
         if (url.startsWith('https:')) {
-          agent = new agentkeepaliveExports.HttpsAgent(agentOptions);
+          agent = new HttpsAgent(agentOptions);
         } else {
           agent = new HttpKeepAliveAgent(agentOptions);
         }
@@ -6931,6 +7330,11 @@ const GetLatestBlockhashRpcResult = jsonRpcResultAndContext(superstruct.type({
   blockhash: superstruct.string(),
   lastValidBlockHeight: superstruct.number()
 }));
+
+/**
+ * Expected JSON RPC response for the "isBlockhashValid" message
+ */
+const IsBlockhashValidRpcResult = jsonRpcResultAndContext(superstruct.boolean());
 const PerfSampleResult = superstruct.type({
   slot: superstruct.number(),
   numTransactions: superstruct.number(),
@@ -6966,6 +7370,110 @@ const SendTransactionRpcResult = jsonRpcResult(superstruct.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
+ */
+
+/**
+ * Callback function for signature status notifications
+ */
+
+/**
+ * Signature status notification with transaction result
+ */
+
+/**
+ * Signature received notification
+ */
+
+/**
+ * Callback function for signature notifications
+ */
+
+/**
+ * Signature subscription options
+ */
+
+/**
+ * Callback function for root change notifications
+ */
+
 /**
  * @internal
  */
@@ -6991,66 +7499,60 @@ const LogsNotificationResult = superstruct.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
    *
@@ -7058,33 +7560,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 => {
@@ -7480,6 +8026,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 {
@@ -7518,6 +8066,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;
@@ -7584,7 +8134,7 @@ class Connection {
             value: result
           };
           resolve({
-            __type: exports.TransactionStatus.PROCESSED,
+            __type: TransactionStatus.PROCESSED,
             response
           });
         }, commitment);
@@ -7642,7 +8192,7 @@ class Connection {
             }
             done = true;
             resolve({
-              __type: exports.TransactionStatus.PROCESSED,
+              __type: TransactionStatus.PROCESSED,
               response: {
                 context,
                 value
@@ -7697,7 +8247,7 @@ class Connection {
           if (done) return;
         }
         resolve({
-          __type: exports.TransactionStatus.BLOCKHEIGHT_EXCEEDED
+          __type: TransactionStatus.BLOCKHEIGHT_EXCEEDED
         });
       })();
     });
@@ -7712,7 +8262,7 @@ class Connection {
     let result;
     try {
       const outcome = await Promise.race([cancellationPromise, confirmationPromise, expiryPromise]);
-      if (outcome.__type === exports.TransactionStatus.PROCESSED) {
+      if (outcome.__type === TransactionStatus.PROCESSED) {
         result = outcome.response;
       } else {
         throw new TransactionExpiredBlockheightExceededError(signature);
@@ -7761,7 +8311,7 @@ class Connection {
         ) {
           if (nonceValue !== currentNonceValue) {
             resolve({
-              __type: exports.TransactionStatus.NONCE_INVALID,
+              __type: TransactionStatus.NONCE_INVALID,
               slotInWhichNonceDidAdvance: lastCheckedSlot
             });
             return;
@@ -7784,7 +8334,7 @@ class Connection {
     let result;
     try {
       const outcome = await Promise.race([cancellationPromise, confirmationPromise, expiryPromise]);
-      if (outcome.__type === exports.TransactionStatus.PROCESSED) {
+      if (outcome.__type === TransactionStatus.PROCESSED) {
         result = outcome.response;
       } else {
         // Double check that the transaction is indeed unconfirmed.
@@ -7868,7 +8418,7 @@ class Connection {
           }
       }
       timeoutId = setTimeout(() => resolve({
-        __type: exports.TransactionStatus.TIMED_OUT,
+        __type: TransactionStatus.TIMED_OUT,
         timeoutMs
       }), timeoutMs);
     });
@@ -7882,7 +8432,7 @@ class Connection {
     let result;
     try {
       const outcome = await Promise.race([confirmationPromise, expiryPromise]);
-      if (outcome.__type === exports.TransactionStatus.PROCESSED) {
+      if (outcome.__type === TransactionStatus.PROCESSED) {
         result = outcome.response;
       } else {
         throw new TransactionExpiredTimeoutError(signature, outcome.timeoutMs / 1000);
@@ -8261,6 +8811,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 = superstruct.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
    */
@@ -8292,10 +8859,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,
@@ -8356,6 +8937,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 {
@@ -8395,11 +8980,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
    */
@@ -8435,8 +9015,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,
@@ -8515,8 +9097,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,
@@ -8942,8 +9528,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;
@@ -9054,10 +9642,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)) {
@@ -9465,7 +10055,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) {
@@ -9947,6 +10537,10 @@ class Keypair {
   }
 }
 
+/**
+ * An enumeration of valid LookupTableInstructionType's
+ */
+
 /**
  * An enumeration of valid address lookup table InstructionType's
  * @internal
@@ -10288,6 +10882,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
@@ -10376,6 +10986,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__namespace.struct([BufferLayout__namespace.u8('numSignatures'), BufferLayout__namespace.u8('padding'), BufferLayout__namespace.u16('signatureOffset'), BufferLayout__namespace.u16('signatureInstructionIndex'), BufferLayout__namespace.u16('publicKeyOffset'), BufferLayout__namespace.u16('publicKeyInstructionIndex'), BufferLayout__namespace.u16('messageDataOffset'), BufferLayout__namespace.u16('messageDataSize'), BufferLayout__namespace.u16('messageInstructionIndex')]);
 class Ed25519Program {
   /**
@@ -10473,6 +11087,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__namespace.struct([BufferLayout__namespace.u8('numSignatures'), BufferLayout__namespace.u16('signatureOffset'), BufferLayout__namespace.u8('signatureInstructionIndex'), BufferLayout__namespace.u16('ethAddressOffset'), BufferLayout__namespace.u8('ethAddressInstructionIndex'), BufferLayout__namespace.u16('messageDataOffset'), BufferLayout__namespace.u16('messageDataSize'), BufferLayout__namespace.u8('messageInstructionIndex'), BufferLayout__namespace.blob(20, 'ethAddress'), BufferLayout__namespace.blob(64, 'signature'), BufferLayout__namespace.u8('recoveryId')]);
 class Secp256k1Program {
   /**
@@ -10608,17 +11230,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;
@@ -10628,18 +11248,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;
@@ -10651,6 +11268,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
  */
@@ -11339,6 +11989,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;
 
 /**
@@ -11363,6 +12020,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
  */
@@ -11494,6 +12167,8 @@ class VoteInstruction {
  * An enumeration of valid VoteInstructionType's
  */
 
+/** @internal */
+
 const VOTE_INSTRUCTION_LAYOUTS = Object.freeze({
   InitializeAccount: {
     index: 0,
@@ -11730,6 +12405,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');
@@ -11738,6 +12422,10 @@ const VALIDATOR_INFO_KEY = new PublicKey('Va1idator1nfo1111111111111111111111111
  * @internal
  */
 
+/**
+ * Info used to identity validators.
+ */
+
 const InfoString = superstruct.type({
   name: superstruct.string(),
   website: superstruct.optional(superstruct.string()),
@@ -11749,14 +12437,6 @@ const InfoString = superstruct.type({
  * ValidatorInfo class
  */
 class ValidatorInfo {
-  /**
-   * validator public key
-   */
-
-  /**
-   * validator information
-   */
-
   /**
    * Construct a valid ValidatorInfo
    *
@@ -11764,7 +12444,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;
@@ -11805,6 +12491,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
  *
@@ -11944,9 +12635,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;
@@ -12041,6 +12730,7 @@ exports.TransactionExpiredNonceInvalidError = TransactionExpiredNonceInvalidErro
 exports.TransactionExpiredTimeoutError = TransactionExpiredTimeoutError;
 exports.TransactionInstruction = TransactionInstruction;
 exports.TransactionMessage = TransactionMessage;
+exports.TransactionStatus = TransactionStatus;
 exports.VALIDATOR_INFO_KEY = VALIDATOR_INFO_KEY;
 exports.VERSION_PREFIX_MASK = VERSION_PREFIX_MASK;
 exports.VOTE_PROGRAM_ID = VOTE_PROGRAM_ID;