@solana/web3.js 1.41.8 → 1.42.0

package/lib/index.d.ts

@@ -338,6 +338,11 @@ declare module '@solana/web3.js' {
    * Transaction signature as base-58 encoded string
    */
   export type TransactionSignature = string;
+  export const enum TransactionStatus {
+    BLOCKHEIGHT_EXCEEDED = 0,
+    PROCESSED = 1,
+    TIMED_OUT = 2,
+  }
   /**
    * Account metadata used to define instructions
    */
@@ -394,17 +399,29 @@ declare module '@solana/web3.js' {
   };
   /**
    * List of Transaction object fields that may be initialized at construction
-   *
    */
-  export type TransactionCtorFields = {
-    /** A recent blockhash */
-    recentBlockhash?: Blockhash | null;
+  export type TransactionCtorFields_DEPRECATED = {
     /** Optional nonce information used for offline nonce'd transactions */
     nonceInfo?: NonceInformation | null;
     /** The transaction fee payer */
     feePayer?: PublicKey | null;
     /** One or more signatures */
     signatures?: Array<SignaturePubkeyPair>;
+    /** A recent blockhash */
+    recentBlockhash?: Blockhash;
+  };
+  /**
+   * List of Transaction object fields that may be initialized at construction
+   */
+  export type TransactionBlockhashCtor = {
+    /** The transaction fee payer */
+    feePayer?: PublicKey | null;
+    /** One or more signatures */
+    signatures?: Array<SignaturePubkeyPair>;
+    /** A recent blockhash */
+    blockhash: Blockhash;
+    /** the last block chain can advance to before tx is exportd expired */
+    lastValidBlockHeight: number;
   };
   /**
    * Nonce information to be used to build an offline Transaction.
@@ -440,15 +457,21 @@ declare module '@solana/web3.js' {
      * A recent transaction id. Must be populated by the caller
      */
     recentBlockhash?: Blockhash;
+    /**
+     * the last block chain can advance to before tx is exportd expired
+     * */
+    lastValidBlockHeight?: number;
     /**
      * Optional Nonce information. If populated, transaction will use a durable
      * Nonce hash instead of a recentBlockhash. Must be populated by the caller
      */
     nonceInfo?: NonceInformation;
+    constructor(opts?: TransactionBlockhashCtor);
     /**
-     * Construct an empty Transaction
+     * @deprecated `TransactionCtorFields` has been deprecated and will be removed in a future version.
+     * Please supply a `TransactionBlockhashCtor` instead.
      */
-    constructor(opts?: TransactionCtorFields);
+    constructor(opts?: TransactionCtorFields_DEPRECATED);
     /**
      * Add one or more instructions to this Transaction
      */
@@ -602,6 +625,17 @@ declare module '@solana/web3.js' {
     /** response value */
     value: T;
   };
+  export type BlockhashWithExpiryBlockHeight = Readonly<{
+    blockhash: Blockhash;
+    lastValidBlockHeight: number;
+  }>;
+  /**
+   * A strategy for confirming transactions that uses the last valid
+   * block height for a given blockhash to check for transaction expiration.
+   */
+  export type BlockheightBasedTransactionConfimationStrategy = {
+    signature: TransactionSignature;
+  } & BlockhashWithExpiryBlockHeight;
   /**
    * The level of commitment desired when querying state
    * <pre>
@@ -1624,11 +1658,13 @@ declare module '@solana/web3.js' {
         account: AccountInfo<Buffer | ParsedAccountData>;
       }>
     >;
-    /**
-     * Confirm the transaction identified by the specified signature.
-     */
     confirmTransaction(
-      signature: TransactionSignature,
+      strategy: BlockheightBasedTransactionConfimationStrategy,
+      commitment?: Commitment,
+    ): Promise<RpcResponseAndContext<SignatureResult>>;
+    /** @deprecated Instead, call `confirmTransaction` using a `TransactionConfirmationConfig` */
+    confirmTransaction(
+      strategy: TransactionSignature,
       commitment?: Commitment,
     ): Promise<RpcResponseAndContext<SignatureResult>>;
     /**
@@ -1756,22 +1792,18 @@ declare module '@solana/web3.js' {
     }>;
     /**
      * Fetch the latest blockhash from the cluster
-     * @return {Promise<{blockhash: Blockhash, lastValidBlockHeight: number}>}
+     * @return {Promise<BlockhashWithExpiryBlockHeight>}
      */
-    getLatestBlockhash(commitment?: Commitment): Promise<{
-      blockhash: Blockhash;
-      lastValidBlockHeight: number;
-    }>;
+    getLatestBlockhash(
+      commitment?: Commitment,
+    ): Promise<BlockhashWithExpiryBlockHeight>;
     /**
      * Fetch the latest blockhash from the cluster
-     * @return {Promise<{blockhash: Blockhash, lastValidBlockHeight: number}>}
+     * @return {Promise<BlockhashWithExpiryBlockHeight>}
      */
-    getLatestBlockhashAndContext(commitment?: Commitment): Promise<
-      RpcResponseAndContext<{
-        blockhash: Blockhash;
-        lastValidBlockHeight: number;
-      }>
-    >;
+    getLatestBlockhashAndContext(
+      commitment?: Commitment,
+    ): Promise<RpcResponseAndContext<BlockhashWithExpiryBlockHeight>>;
     /**
      * Fetch the node version
      */
@@ -3320,9 +3352,20 @@ declare module '@solana/web3.js' {
    *
    * @param {Connection} connection
    * @param {Buffer} rawTransaction
+   * @param {BlockheightBasedTransactionConfimationStrategy} confirmationStrategy
    * @param {ConfirmOptions} [options]
    * @returns {Promise<TransactionSignature>}
    */
+  export function sendAndConfirmRawTransaction(
+    connection: Connection,
+    rawTransaction: Buffer,
+    confirmationStrategy: BlockheightBasedTransactionConfimationStrategy,
+    options?: ConfirmOptions,
+  ): Promise<TransactionSignature>;
+  /**
+   * @deprecated Calling `sendAndConfirmRawTransaction()` without a `confirmationStrategy`
+   * is no longer supported and will be removed in a future version.
+   */
   export function sendAndConfirmRawTransaction(
     connection: Connection,
     rawTransaction: Buffer,

package/lib/index.esm.js

@@ -2353,9 +2353,17 @@ function assert (condition, message) {
   }
 }
 
+let TransactionStatus;
 /**
  * Default (empty) signature
  */
+
+(function (TransactionStatus) {
+  TransactionStatus[TransactionStatus["BLOCKHEIGHT_EXCEEDED"] = 0] = "BLOCKHEIGHT_EXCEEDED";
+  TransactionStatus[TransactionStatus["PROCESSED"] = 1] = "PROCESSED";
+  TransactionStatus[TransactionStatus["TIMED_OUT"] = 2] = "TIMED_OUT";
+})(TransactionStatus || (TransactionStatus = {}));
+
 const DEFAULT_SIGNATURE = Buffer.alloc(SIGNATURE_LENGTH_IN_BYTES).fill(0);
 /**
  * Account metadata used to define instructions
@@ -2446,10 +2454,23 @@ class Transaction {
     this.feePayer = void 0;
     this.instructions = [];
     this.recentBlockhash = void 0;
+    this.lastValidBlockHeight = void 0;
     this.nonceInfo = void 0;
     this._message = void 0;
     this._json = void 0;
-    opts && Object.assign(this, opts);
+
+    if (!opts) {
+      return;
+    } else if (Object.prototype.hasOwnProperty.call(opts, 'lastValidBlockHeight')) {
+      const newOpts = opts;
+      Object.assign(this, newOpts);
+      this.recentBlockhash = newOpts.blockhash;
+      this.lastValidBlockHeight = newOpts.lastValidBlockHeight;
+    } else {
+      const oldOpts = opts;
+      Object.assign(this, oldOpts);
+      this.recentBlockhash = oldOpts.recentBlockhash;
+    }
   }
   /**
    * @internal
@@ -3059,7 +3080,11 @@ async function sendAndConfirmTransaction(connection, transaction, signers, optio
     maxRetries: options.maxRetries
   };
   const signature = await connection.sendTransaction(transaction, signers, sendOptions);
-  const status = (await connection.confirmTransaction(signature, options && options.commitment)).value;
+  const status = transaction.recentBlockhash != null && transaction.lastValidBlockHeight != null ? (await connection.confirmTransaction({
+    signature: signature,
+    blockhash: transaction.recentBlockhash,
+    lastValidBlockHeight: transaction.lastValidBlockHeight
+  }, options && options.commitment)).value : (await connection.confirmTransaction(signature, options && options.commitment)).value;
 
   if (status.err) {
     throw new Error(`Transaction ${signature} failed (${JSON.stringify(status)})`);
@@ -4459,16 +4484,28 @@ const NUM_SLOTS_PER_SECOND = NUM_TICKS_PER_SECOND / DEFAULT_TICKS_PER_SLOT;
 
 const MS_PER_SLOT = 1000 / NUM_SLOTS_PER_SECOND;
 
-function promiseTimeout(promise, timeoutMs) {
-  let timeoutId;
-  const timeoutPromise = new Promise(resolve => {
-    timeoutId = setTimeout(() => resolve(null), timeoutMs);
-  });
-  return Promise.race([promise, timeoutPromise]).then(result => {
-    clearTimeout(timeoutId);
-    return result;
-  });
+class TransactionExpiredBlockheightExceededError extends Error {
+  constructor(signature) {
+    super(`Signature ${signature} has expired: block height exceeded.`);
+    this.signature = void 0;
+    this.signature = signature;
+  }
+
+}
+Object.defineProperty(TransactionExpiredBlockheightExceededError.prototype, 'name', {
+  value: 'TransactionExpiredBlockheightExceededError'
+});
+class TransactionExpiredTimeoutError extends Error {
+  constructor(signature, timeoutSeconds) {
+    super(`Transaction was not confirmed in ${timeoutSeconds.toFixed(2)} seconds. It is ` + 'unknown if it succeeded or failed. Check signature ' + `${signature} using the Solana Explorer or CLI tools.`);
+    this.signature = void 0;
+    this.signature = signature;
+  }
+
 }
+Object.defineProperty(TransactionExpiredTimeoutError.prototype, 'name', {
+  value: 'TransactionExpiredTimeoutError'
+});
 
 function makeWebsocketUrl(endpoint) {
   let url = new URL(endpoint);
@@ -5463,7 +5500,7 @@ class Connection {
     this._disableBlockhashCaching = false;
     this._pollingBlockhash = false;
     this._blockhashInfo = {
-      recentBlockhash: null,
+      latestBlockhash: null,
       lastFetch: 0,
       transactionSignatures: [],
       simulatedSignatures: []
@@ -5944,67 +5981,124 @@ class Connection {
 
     return res.result;
   }
-  /**
-   * Confirm the transaction identified by the specified signature.
-   */
 
+  // eslint-disable-next-line no-dupe-class-members
+  async confirmTransaction(strategy, commitment) {
+    let rawSignature;
+
+    if (typeof strategy == 'string') {
+      rawSignature = strategy;
+    } else {
+      const config = strategy;
+      rawSignature = config.signature;
+    }
 
-  async confirmTransaction(signature, commitment) {
     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;
+    let timeoutId;
     let subscriptionId;
-    let response = null;
-    const confirmPromise = new Promise((resolve, reject) => {
+    let done = false;
+    const confirmationPromise = new Promise((resolve, reject) => {
       try {
-        subscriptionId = this.onSignature(signature, (result, context) => {
+        subscriptionId = this.onSignature(rawSignature, (result, context) => {
           subscriptionId = undefined;
-          response = {
+          const response = {
             context,
             value: result
           };
-          resolve(null);
+          done = true;
+          resolve({
+            __type: TransactionStatus.PROCESSED,
+            response
+          });
         }, subscriptionCommitment);
       } catch (err) {
         reject(err);
       }
     });
-    let timeoutMs = this._confirmTransactionInitialTimeout || 60 * 1000;
-
-    switch (subscriptionCommitment) {
-      case 'processed':
-      case 'recent':
-      case 'single':
-      case 'confirmed':
-      case 'singleGossip':
-        {
-          timeoutMs = this._confirmTransactionInitialTimeout || 30 * 1000;
-          break;
+
+    const checkBlockHeight = async () => {
+      try {
+        const blockHeight = await this.getBlockHeight(commitment);
+        return blockHeight;
+      } catch (_e) {
+        return -1;
+      }
+    };
+
+    const expiryPromise = new Promise(resolve => {
+      if (typeof strategy === 'string') {
+        let timeoutMs = this._confirmTransactionInitialTimeout || 60 * 1000;
+
+        switch (subscriptionCommitment) {
+          case 'processed':
+          case 'recent':
+          case 'single':
+          case 'confirmed':
+          case 'singleGossip':
+            {
+              timeoutMs = this._confirmTransactionInitialTimeout || 30 * 1000;
+              break;
+            }
         }
-    }
+
+        timeoutId = setTimeout(() => resolve({
+          __type: TransactionStatus.TIMED_OUT,
+          timeoutMs
+        }), timeoutMs);
+      } else {
+        let config = strategy;
+
+        (async () => {
+          let currentBlockHeight = await checkBlockHeight();
+          if (done) return;
+
+          while (currentBlockHeight <= config.lastValidBlockHeight) {
+            await sleep(1000);
+            if (done) return;
+            currentBlockHeight = await checkBlockHeight();
+            if (done) return;
+          }
+
+          resolve({
+            __type: TransactionStatus.BLOCKHEIGHT_EXCEEDED
+          });
+        })();
+      }
+    });
+    let result;
 
     try {
-      await promiseTimeout(confirmPromise, timeoutMs);
+      const outcome = await Promise.race([confirmationPromise, expiryPromise]);
+
+      switch (outcome.__type) {
+        case TransactionStatus.BLOCKHEIGHT_EXCEEDED:
+          throw new TransactionExpiredBlockheightExceededError(rawSignature);
+
+        case TransactionStatus.PROCESSED:
+          result = outcome.response;
+          break;
+
+        case TransactionStatus.TIMED_OUT:
+          throw new TransactionExpiredTimeoutError(rawSignature, outcome.timeoutMs / 1000);
+      }
     } finally {
+      clearTimeout(timeoutId);
+
       if (subscriptionId) {
         this.removeSignatureListener(subscriptionId);
       }
     }
 
-    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.`);
-    }
-
-    return response;
+    return result;
   }
   /**
    * Return the list of nodes that are currently participating in the cluster
@@ -6369,7 +6463,7 @@ class Connection {
   }
   /**
    * Fetch the latest blockhash from the cluster
-   * @return {Promise<{blockhash: Blockhash, lastValidBlockHeight: number}>}
+   * @return {Promise<BlockhashWithExpiryBlockHeight>}
    */
 
 
@@ -6383,7 +6477,7 @@ class Connection {
   }
   /**
    * Fetch the latest blockhash from the cluster
-   * @return {Promise<{blockhash: Blockhash, lastValidBlockHeight: number}>}
+   * @return {Promise<BlockhashWithExpiryBlockHeight>}
    */
 
 
@@ -6966,7 +7060,7 @@ class Connection {
    */
 
 
-  async _recentBlockhash(disableCache) {
+  async _blockhashWithExpiryBlockHeight(disableCache) {
     if (!disableCache) {
       // Wait for polling to finish
       while (this._pollingBlockhash) {
@@ -6977,8 +7071,8 @@ class Connection {
 
       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;
       }
     }
 
@@ -6994,20 +7088,20 @@ class Connection {
 
     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
 
 
@@ -7029,13 +7123,11 @@ class Connection {
 
     if (transactionOrMessage instanceof Transaction) {
       let originalTx = 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
 
@@ -7048,7 +7140,9 @@ class Connection {
       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;
         transaction.sign(...signers);
 
@@ -7132,7 +7226,9 @@ class Connection {
       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) {
@@ -7232,6 +7328,7 @@ class Connection {
 
 
   _wsOnError(err) {
+    this._rpcWebSocketConnected = false;
     console.error('ws error:', err.message);
   }
   /**
@@ -7240,6 +7337,7 @@ class Connection {
 
 
   _wsOnClose(code) {
+    this._rpcWebSocketConnected = false;
     this._rpcWebSocketGeneration++;
 
     if (this._rpcWebSocketHeartbeat) {
@@ -9571,16 +9669,36 @@ VoteProgram.space = 3731;
  *
  * @param {Connection} connection
  * @param {Buffer} rawTransaction
+ * @param {BlockheightBasedTransactionConfimationStrategy} confirmationStrategy
  * @param {ConfirmOptions} [options]
  * @returns {Promise<TransactionSignature>}
  */
-async function sendAndConfirmRawTransaction(connection, rawTransaction, options) {
+
+/**
+ * @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
+async function sendAndConfirmRawTransaction(connection, rawTransaction, confirmationStrategyOrConfirmOptions, maybeConfirmOptions) {
+  let confirmationStrategy;
+  let options;
+
+  if (confirmationStrategyOrConfirmOptions && Object.prototype.hasOwnProperty.call(confirmationStrategyOrConfirmOptions, 'lastValidBlockHeight')) {
+    confirmationStrategy = confirmationStrategyOrConfirmOptions;
+    options = maybeConfirmOptions;
+  } else {
+    options = confirmationStrategyOrConfirmOptions;
+  }
+
   const sendOptions = options && {
     skipPreflight: options.skipPreflight,
     preflightCommitment: options.preflightCommitment || options.commitment
   };
   const signature = await connection.sendRawTransaction(rawTransaction, sendOptions);
-  const status = (await connection.confirmTransaction(signature, options && options.commitment)).value;
+  const commitment = options && options.commitment;
+  const confirmationPromise = confirmationStrategy ? connection.confirmTransaction(confirmationStrategy, commitment) : connection.confirmTransaction(signature, commitment);
+  const status = (await confirmationPromise).value;
 
   if (status.err) {
     throw new Error(`Raw transaction ${signature} failed (${JSON.stringify(status)})`);
@@ -9627,5 +9745,5 @@ function clusterApiUrl(cluster, tls) {
 
 const LAMPORTS_PER_SOL = 1000000000;
 
-export { Account, Authorized, BLOCKHASH_CACHE_TIMEOUT_MS, BPF_LOADER_DEPRECATED_PROGRAM_ID, BPF_LOADER_PROGRAM_ID, BpfLoader, COMPUTE_BUDGET_INSTRUCTION_LAYOUTS, ComputeBudgetInstruction, ComputeBudgetProgram, Connection, Ed25519Program, Enum, EpochSchedule, FeeCalculatorLayout, Keypair, LAMPORTS_PER_SOL, Loader, Lockup, MAX_SEED_LENGTH, Message, NONCE_ACCOUNT_LENGTH, NonceAccount, PACKET_DATA_SIZE, PublicKey, SIGNATURE_LENGTH_IN_BYTES, SOLANA_SCHEMA, STAKE_CONFIG_ID, STAKE_INSTRUCTION_LAYOUTS, SYSTEM_INSTRUCTION_LAYOUTS, SYSVAR_CLOCK_PUBKEY, SYSVAR_EPOCH_SCHEDULE_PUBKEY, SYSVAR_INSTRUCTIONS_PUBKEY, SYSVAR_RECENT_BLOCKHASHES_PUBKEY, SYSVAR_RENT_PUBKEY, SYSVAR_REWARDS_PUBKEY, SYSVAR_SLOT_HASHES_PUBKEY, SYSVAR_SLOT_HISTORY_PUBKEY, SYSVAR_STAKE_HISTORY_PUBKEY, Secp256k1Program, SendTransactionError, StakeAuthorizationLayout, StakeInstruction, StakeProgram, Struct, SystemInstruction, SystemProgram, Transaction, TransactionInstruction, VALIDATOR_INFO_KEY, VOTE_PROGRAM_ID, ValidatorInfo, VoteAccount, VoteAuthorizationLayout, VoteInit, VoteInstruction, VoteProgram, clusterApiUrl, sendAndConfirmRawTransaction, sendAndConfirmTransaction };
+export { Account, Authorized, BLOCKHASH_CACHE_TIMEOUT_MS, BPF_LOADER_DEPRECATED_PROGRAM_ID, BPF_LOADER_PROGRAM_ID, BpfLoader, COMPUTE_BUDGET_INSTRUCTION_LAYOUTS, ComputeBudgetInstruction, ComputeBudgetProgram, Connection, Ed25519Program, Enum, EpochSchedule, FeeCalculatorLayout, Keypair, LAMPORTS_PER_SOL, Loader, Lockup, MAX_SEED_LENGTH, Message, NONCE_ACCOUNT_LENGTH, NonceAccount, PACKET_DATA_SIZE, PublicKey, SIGNATURE_LENGTH_IN_BYTES, SOLANA_SCHEMA, STAKE_CONFIG_ID, STAKE_INSTRUCTION_LAYOUTS, SYSTEM_INSTRUCTION_LAYOUTS, SYSVAR_CLOCK_PUBKEY, SYSVAR_EPOCH_SCHEDULE_PUBKEY, SYSVAR_INSTRUCTIONS_PUBKEY, SYSVAR_RECENT_BLOCKHASHES_PUBKEY, SYSVAR_RENT_PUBKEY, SYSVAR_REWARDS_PUBKEY, SYSVAR_SLOT_HASHES_PUBKEY, SYSVAR_SLOT_HISTORY_PUBKEY, SYSVAR_STAKE_HISTORY_PUBKEY, Secp256k1Program, SendTransactionError, StakeAuthorizationLayout, StakeInstruction, StakeProgram, Struct, SystemInstruction, SystemProgram, Transaction, TransactionInstruction, TransactionStatus, VALIDATOR_INFO_KEY, VOTE_PROGRAM_ID, ValidatorInfo, VoteAccount, VoteAuthorizationLayout, VoteInit, VoteInstruction, VoteProgram, clusterApiUrl, sendAndConfirmRawTransaction, sendAndConfirmTransaction };
 //# sourceMappingURL=index.esm.js.map