@solana/web3.js 1.66.5 → 1.67.1

package/lib/index.iife.js

@@ -8352,13 +8352,13 @@ var solanaWeb3 = (function (exports) {
 	        this._bn = new BN(value);
 	      }
 
-	      if (this._bn.byteLength() > 32) {
+	      if (this._bn.byteLength() > PUBLIC_KEY_LENGTH) {
 	        throw new Error(`Invalid public key input`);
 	      }
 	    }
 	  }
 	  /**
-	   * Returns a unique PublicKey for tests and benchmarks using acounter
+	   * Returns a unique PublicKey for tests and benchmarks using a counter
 	   */
 
 
@@ -8465,6 +8465,8 @@ var solanaWeb3 = (function (exports) {
 	  /**
 	   * Async version of createProgramAddressSync
 	   * For backwards compatibility
+	   *
+	   * @deprecated Use {@link createProgramAddressSync} instead
 	   */
 
 	  /* eslint-disable require-await */
@@ -8507,6 +8509,8 @@ var solanaWeb3 = (function (exports) {
 	  /**
 	   * Async version of findProgramAddressSync
 	   * For backwards compatibility
+	   *
+	   * @deprecated Use {@link findProgramAddressSync} instead
 	   */
 
 
@@ -10906,6 +10910,17 @@ var solanaWeb3 = (function (exports) {
 	Object.defineProperty(TransactionExpiredTimeoutError.prototype, 'name', {
 	  value: 'TransactionExpiredTimeoutError'
 	});
+	class TransactionExpiredNonceInvalidError extends Error {
+	  constructor(signature) {
+	    super(`Signature ${signature} has expired: the nonce is no longer valid.`);
+	    this.signature = void 0;
+	    this.signature = signature;
+	  }
+
+	}
+	Object.defineProperty(TransactionExpiredNonceInvalidError.prototype, 'name', {
+	  value: 'TransactionExpiredNonceInvalidError'
+	});
 
 	class MessageAccountKeys {
 	  constructor(staticAccountKeys, accountKeysFromLookups) {
@@ -11743,6 +11758,7 @@ var solanaWeb3 = (function (exports) {
 	  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 = {}));
 
 	const DEFAULT_SIGNATURE = buffer.Buffer.alloc(SIGNATURE_LENGTH_IN_BYTES).fill(0);
@@ -11837,6 +11853,7 @@ var solanaWeb3 = (function (exports) {
 	    this.recentBlockhash = void 0;
 	    this.lastValidBlockHeight = void 0;
 	    this.nonceInfo = void 0;
+	    this.minNonceContextSlot = void 0;
 	    this._message = void 0;
 	    this._json = void 0;
 
@@ -11852,7 +11869,14 @@ var solanaWeb3 = (function (exports) {
 	      this.signatures = opts.signatures;
 	    }
 
-	    if (Object.prototype.hasOwnProperty.call(opts, 'lastValidBlockHeight')) {
+	    if (Object.prototype.hasOwnProperty.call(opts, 'nonceInfo')) {
+	      const {
+	        minContextSlot,
+	        nonceInfo
+	      } = opts;
+	      this.minNonceContextSlot = minContextSlot;
+	      this.nonceInfo = nonceInfo;
+	    } else if (Object.prototype.hasOwnProperty.call(opts, 'lastValidBlockHeight')) {
 	      const {
 	        blockhash,
 	        lastValidBlockHeight
@@ -12485,7 +12509,7 @@ var solanaWeb3 = (function (exports) {
 	    } = header;
 	    const numWritableSignedAccounts = numRequiredSignatures - numReadonlySignedAccounts;
 	    assert$1(numWritableSignedAccounts > 0, 'Message header is invalid');
-	    const numWritableUnsignedAccounts = message.staticAccountKeys.length - numReadonlyUnsignedAccounts;
+	    const numWritableUnsignedAccounts = message.staticAccountKeys.length - numRequiredSignatures - numReadonlyUnsignedAccounts;
 	    assert$1(numWritableUnsignedAccounts >= 0, 'Message header is invalid');
 	    const accountKeys = message.getAccountKeys(args);
 	    const payerKey = accountKeys.get(0);
@@ -12669,11 +12693,28 @@ var solanaWeb3 = (function (exports) {
 	    minContextSlot: options.minContextSlot
 	  };
 	  const signature = await connection.sendTransaction(transaction, signers, sendOptions);
-	  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;
+	  let status;
+
+	  if (transaction.recentBlockhash != null && transaction.lastValidBlockHeight != null) {
+	    status = (await connection.confirmTransaction({
+	      signature: signature,
+	      blockhash: transaction.recentBlockhash,
+	      lastValidBlockHeight: transaction.lastValidBlockHeight
+	    }, options && options.commitment)).value;
+	  } else if (transaction.minNonceContextSlot != null && transaction.nonceInfo != null) {
+	    const {
+	      nonceInstruction
+	    } = transaction.nonceInfo;
+	    const nonceAccountPubkey = nonceInstruction.keys[0].pubkey;
+	    status = (await connection.confirmTransaction({
+	      minContextSlot: transaction.minNonceContextSlot,
+	      nonceAccountPubkey,
+	      nonceValue: transaction.nonceInfo.nonce,
+	      signature
+	    }, options && options.commitment)).value;
+	  } else {
+	    status = (await connection.confirmTransaction(signature, options && options.commitment)).value;
+	  }
 
 	  if (status.err) {
 	    throw new Error(`Transaction ${signature} failed (${JSON.stringify(status)})`);
@@ -12742,6 +12783,9 @@ var solanaWeb3 = (function (exports) {
 
 	const NonceAccountLayout = struct([u32('version'), u32('state'), publicKey('authorizedPubkey'), publicKey('nonce'), struct([FeeCalculatorLayout], 'feeCalculator')]);
 	const NONCE_ACCOUNT_LENGTH = NonceAccountLayout.span;
+	/**
+	 * A durable nonce is a 32 byte value encoded as a base58 string.
+	 */
 
 	/**
 	 * NonceAccount class
@@ -17269,10 +17313,13 @@ var solanaWeb3 = (function (exports) {
 	  };
 	}
 	/**
-	 * @internal
+	 * A strategy for confirming durable nonce transactions.
 	 */
 
 
+	/**
+	 * @internal
+	 */
 	function createRpcResult(result) {
 	  return union([type({
 	    jsonrpc: literal('2.0'),
@@ -18836,25 +18883,45 @@ var solanaWeb3 = (function (exports) {
 	    }
 
 	    assert$1(decodedSignature.length === 64, 'signature has invalid length');
-	    const confirmationCommitment = commitment || this.commitment;
-	    let timeoutId;
+
+	    if (typeof strategy === 'string') {
+	      return await this.confirmTransactionUsingLegacyTimeoutStrategy({
+	        commitment: commitment || this.commitment,
+	        signature: rawSignature
+	      });
+	    } else if ('lastValidBlockHeight' in strategy) {
+	      return await this.confirmTransactionUsingBlockHeightExceedanceStrategy({
+	        commitment: commitment || this.commitment,
+	        strategy
+	      });
+	    } else {
+	      return await this.confirmTransactionUsingDurableNonceStrategy({
+	        commitment: commitment || this.commitment,
+	        strategy
+	      });
+	    }
+	  }
+
+	  getTransactionConfirmationPromise({
+	    commitment,
+	    signature
+	  }) {
 	    let signatureSubscriptionId;
 	    let disposeSignatureSubscriptionStateChangeObserver;
 	    let done = false;
 	    const confirmationPromise = new Promise((resolve, reject) => {
 	      try {
-	        signatureSubscriptionId = this.onSignature(rawSignature, (result, context) => {
+	        signatureSubscriptionId = this.onSignature(signature, (result, context) => {
 	          signatureSubscriptionId = undefined;
 	          const response = {
 	            context,
 	            value: result
 	          };
-	          done = true;
 	          resolve({
 	            __type: exports.TransactionStatus.PROCESSED,
 	            response
 	          });
-	        }, confirmationCommitment);
+	        }, commitment);
 	        const subscriptionSetupPromise = new Promise(resolveSubscriptionSetup => {
 	          if (signatureSubscriptionId == null) {
 	            resolveSubscriptionSetup();
@@ -18870,7 +18937,7 @@ var solanaWeb3 = (function (exports) {
 	        (async () => {
 	          await subscriptionSetupPromise;
 	          if (done) return;
-	          const response = await this.getSignatureStatus(rawSignature);
+	          const response = await this.getSignatureStatus(signature);
 	          if (done) return;
 
 	          if (response == null) {
@@ -18889,7 +18956,7 @@ var solanaWeb3 = (function (exports) {
 	          if (value !== null && value !== void 0 && value.err) {
 	            reject(value.err);
 	          } else {
-	            switch (confirmationCommitment) {
+	            switch (commitment) {
 	              case 'confirmed':
 	              case 'single':
 	              case 'singleGossip':
@@ -18931,81 +18998,279 @@ var solanaWeb3 = (function (exports) {
 	        reject(err);
 	      }
 	    });
+
+	    const abortConfirmation = () => {
+	      if (disposeSignatureSubscriptionStateChangeObserver) {
+	        disposeSignatureSubscriptionStateChangeObserver();
+	        disposeSignatureSubscriptionStateChangeObserver = undefined;
+	      }
+
+	      if (signatureSubscriptionId) {
+	        this.removeSignatureListener(signatureSubscriptionId);
+	        signatureSubscriptionId = undefined;
+	      }
+	    };
+
+	    return {
+	      abortConfirmation,
+	      confirmationPromise
+	    };
+	  }
+
+	  async confirmTransactionUsingBlockHeightExceedanceStrategy({
+	    commitment,
+	    strategy: {
+	      lastValidBlockHeight,
+	      signature
+	    }
+	  }) {
+	    let done = false;
 	    const expiryPromise = new Promise(resolve => {
-	      if (typeof strategy === 'string') {
-	        let timeoutMs = this._confirmTransactionInitialTimeout || 60 * 1000;
-
-	        switch (confirmationCommitment) {
-	          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;
+	        }
+	      };
+
+	      (async () => {
+	        let currentBlockHeight = await checkBlockHeight();
+	        if (done) return;
+
+	        while (currentBlockHeight <= lastValidBlockHeight) {
+	          await sleep(1000);
+	          if (done) return;
+	          currentBlockHeight = await checkBlockHeight();
+	          if (done) return;
 	        }
 
-	        timeoutId = setTimeout(() => resolve({
-	          __type: exports.TransactionStatus.TIMED_OUT,
-	          timeoutMs
-	        }), timeoutMs);
+	        resolve({
+	          __type: exports.TransactionStatus.BLOCKHEIGHT_EXCEEDED
+	        });
+	      })();
+	    });
+	    const {
+	      abortConfirmation,
+	      confirmationPromise
+	    } = this.getTransactionConfirmationPromise({
+	      commitment,
+	      signature
+	    });
+	    let result;
+
+	    try {
+	      const outcome = await Promise.race([confirmationPromise, expiryPromise]);
+
+	      if (outcome.__type === exports.TransactionStatus.PROCESSED) {
+	        result = outcome.response;
 	      } else {
-	        let config = strategy;
+	        throw new TransactionExpiredBlockheightExceededError(signature);
+	      }
+	    } finally {
+	      done = true;
+	      abortConfirmation();
+	    }
 
-	        const checkBlockHeight = async () => {
-	          try {
-	            const blockHeight = await this.getBlockHeight(commitment);
-	            return blockHeight;
-	          } catch (_e) {
-	            return -1;
-	          }
-	        };
+	    return result;
+	  }
 
-	        (async () => {
-	          let currentBlockHeight = await checkBlockHeight();
-	          if (done) return;
+	  async confirmTransactionUsingDurableNonceStrategy({
+	    commitment,
+	    strategy: {
+	      minContextSlot,
+	      nonceAccountPubkey,
+	      nonceValue,
+	      signature
+	    }
+	  }) {
+	    let done = false;
+	    const expiryPromise = new Promise(resolve => {
+	      let currentNonceValue = nonceValue;
+	      let lastCheckedSlot = null;
 
-	          while (currentBlockHeight <= config.lastValidBlockHeight) {
-	            await sleep(1000);
-	            if (done) return;
-	            currentBlockHeight = await checkBlockHeight();
-	            if (done) return;
+	      const getCurrentNonceValue = async () => {
+	        try {
+	          const {
+	            context,
+	            value: nonceAccount
+	          } = await this.getNonceAndContext(nonceAccountPubkey, {
+	            commitment,
+	            minContextSlot
+	          });
+	          lastCheckedSlot = context.slot;
+	          return nonceAccount === null || nonceAccount === void 0 ? void 0 : nonceAccount.nonce;
+	        } catch (e) {
+	          // If for whatever reason we can't reach/read the nonce
+	          // account, just keep using the last-known value.
+	          return currentNonceValue;
+	        }
+	      };
+
+	      (async () => {
+	        currentNonceValue = await getCurrentNonceValue();
+	        if (done) return;
+
+	        while (true // eslint-disable-line no-constant-condition
+	        ) {
+	          if (nonceValue !== currentNonceValue) {
+	            resolve({
+	              __type: exports.TransactionStatus.NONCE_INVALID,
+	              slotInWhichNonceDidAdvance: lastCheckedSlot
+	            });
+	            return;
 	          }
 
-	          resolve({
-	            __type: exports.TransactionStatus.BLOCKHEIGHT_EXCEEDED
-	          });
-	        })();
-	      }
+	          await sleep(2000);
+	          if (done) return;
+	          currentNonceValue = await getCurrentNonceValue();
+	          if (done) return;
+	        }
+	      })();
+	    });
+	    const {
+	      abortConfirmation,
+	      confirmationPromise
+	    } = this.getTransactionConfirmationPromise({
+	      commitment,
+	      signature
 	    });
 	    let result;
 
 	    try {
 	      const outcome = await Promise.race([confirmationPromise, expiryPromise]);
 
-	      switch (outcome.__type) {
-	        case exports.TransactionStatus.BLOCKHEIGHT_EXCEEDED:
-	          throw new TransactionExpiredBlockheightExceededError(rawSignature);
+	      if (outcome.__type === exports.TransactionStatus.PROCESSED) {
+	        result = outcome.response;
+	      } else {
+	        var _signatureStatus;
+
+	        // Double check that the transaction is indeed unconfirmed.
+	        let signatureStatus;
+
+	        while (true // eslint-disable-line no-constant-condition
+	        ) {
+	          var _outcome$slotInWhichN;
+
+	          const status = await this.getSignatureStatus(signature);
+
+	          if (status == null) {
+	            break;
+	          }
 
-	        case exports.TransactionStatus.PROCESSED:
-	          result = outcome.response;
+	          if (status.context.slot < ((_outcome$slotInWhichN = outcome.slotInWhichNonceDidAdvance) !== null && _outcome$slotInWhichN !== void 0 ? _outcome$slotInWhichN : minContextSlot)) {
+	            await sleep(400);
+	            continue;
+	          }
+
+	          signatureStatus = status;
 	          break;
+	        }
+
+	        if ((_signatureStatus = signatureStatus) !== null && _signatureStatus !== void 0 && _signatureStatus.value) {
+	          const commitmentForStatus = commitment || 'finalized';
+	          const {
+	            confirmationStatus
+	          } = signatureStatus.value;
+
+	          switch (commitmentForStatus) {
+	            case 'processed':
+	            case 'recent':
+	              if (confirmationStatus !== 'processed' && confirmationStatus !== 'confirmed' && confirmationStatus !== 'finalized') {
+	                throw new TransactionExpiredNonceInvalidError(signature);
+	              }
+
+	              break;
+
+	            case 'confirmed':
+	            case 'single':
+	            case 'singleGossip':
+	              if (confirmationStatus !== 'confirmed' && confirmationStatus !== 'finalized') {
+	                throw new TransactionExpiredNonceInvalidError(signature);
+	              }
 
-	        case exports.TransactionStatus.TIMED_OUT:
-	          throw new TransactionExpiredTimeoutError(rawSignature, outcome.timeoutMs / 1000);
+	              break;
+
+	            case 'finalized':
+	            case 'max':
+	            case 'root':
+	              if (confirmationStatus !== 'finalized') {
+	                throw new TransactionExpiredNonceInvalidError(signature);
+	              }
+
+	              break;
+
+	            default:
+	              // Exhaustive switch.
+	              // eslint-disable-next-line @typescript-eslint/no-unused-vars
+	              (_ => {})(commitmentForStatus);
+
+	          }
+
+	          result = {
+	            context: signatureStatus.context,
+	            value: {
+	              err: signatureStatus.value.err
+	            }
+	          };
+	        } else {
+	          throw new TransactionExpiredNonceInvalidError(signature);
+	        }
 	      }
 	    } finally {
-	      clearTimeout(timeoutId);
+	      done = true;
+	      abortConfirmation();
+	    }
 
-	      if (disposeSignatureSubscriptionStateChangeObserver) {
-	        disposeSignatureSubscriptionStateChangeObserver();
+	    return result;
+	  }
+
+	  async confirmTransactionUsingLegacyTimeoutStrategy({
+	    commitment,
+	    signature
+	  }) {
+	    let timeoutId;
+	    const expiryPromise = new Promise(resolve => {
+	      let timeoutMs = this._confirmTransactionInitialTimeout || 60 * 1000;
+
+	      switch (commitment) {
+	        case 'processed':
+	        case 'recent':
+	        case 'single':
+	        case 'confirmed':
+	        case 'singleGossip':
+	          {
+	            timeoutMs = this._confirmTransactionInitialTimeout || 30 * 1000;
+	            break;
+	          }
 	      }
 
-	      if (signatureSubscriptionId) {
-	        this.removeSignatureListener(signatureSubscriptionId);
+	      timeoutId = setTimeout(() => resolve({
+	        __type: exports.TransactionStatus.TIMED_OUT,
+	        timeoutMs
+	      }), timeoutMs);
+	    });
+	    const {
+	      abortConfirmation,
+	      confirmationPromise
+	    } = this.getTransactionConfirmationPromise({
+	      commitment,
+	      signature
+	    });
+	    let result;
+
+	    try {
+	      const outcome = await Promise.race([confirmationPromise, expiryPromise]);
+
+	      if (outcome.__type === exports.TransactionStatus.PROCESSED) {
+	        result = outcome.response;
+	      } else {
+	        throw new TransactionExpiredTimeoutError(signature, outcome.timeoutMs / 1000);
 	      }
+	    } finally {
+	      clearTimeout(timeoutId);
+	      abortConfirmation();
 	    }
 
 	    return result;
@@ -20061,11 +20326,11 @@ var solanaWeb3 = (function (exports) {
 	   */
 
 
-	  async getNonceAndContext(nonceAccount, commitment) {
+	  async getNonceAndContext(nonceAccount, commitmentOrConfig) {
 	    const {
 	      context,
 	      value: accountInfo
-	    } = await this.getAccountInfoAndContext(nonceAccount, commitment);
+	    } = await this.getAccountInfoAndContext(nonceAccount, commitmentOrConfig);
 	    let value = null;
 
 	    if (accountInfo !== null) {
@@ -20082,8 +20347,8 @@ var solanaWeb3 = (function (exports) {
 	   */
 
 
-	  async getNonce(nonceAccount, commitment) {
-	    return await this.getNonceAndContext(nonceAccount, commitment).then(x => x.value).catch(e => {
+	  async getNonce(nonceAccount, commitmentOrConfig) {
+	    return await this.getNonceAndContext(nonceAccount, commitmentOrConfig).then(x => x.value).catch(e => {
 	      throw new Error('failed to get nonce for account ' + nonceAccount.toBase58() + ': ' + e);
 	    });
 	  }
@@ -24716,6 +24981,9 @@ var solanaWeb3 = (function (exports) {
 	  if (confirmationStrategyOrConfirmOptions && Object.prototype.hasOwnProperty.call(confirmationStrategyOrConfirmOptions, 'lastValidBlockHeight')) {
 	    confirmationStrategy = confirmationStrategyOrConfirmOptions;
 	    options = maybeConfirmOptions;
+	  } else if (confirmationStrategyOrConfirmOptions && Object.prototype.hasOwnProperty.call(confirmationStrategyOrConfirmOptions, 'nonceValue')) {
+	    confirmationStrategy = confirmationStrategyOrConfirmOptions;
+	    options = maybeConfirmOptions;
 	  } else {
 	    options = confirmationStrategyOrConfirmOptions;
 	  }
@@ -24800,6 +25068,7 @@ var solanaWeb3 = (function (exports) {
 	exports.SystemProgram = SystemProgram;
 	exports.Transaction = Transaction;
 	exports.TransactionExpiredBlockheightExceededError = TransactionExpiredBlockheightExceededError;
+	exports.TransactionExpiredNonceInvalidError = TransactionExpiredNonceInvalidError;
 	exports.TransactionExpiredTimeoutError = TransactionExpiredTimeoutError;
 	exports.TransactionInstruction = TransactionInstruction;
 	exports.TransactionMessage = TransactionMessage;