@solana/web3.js 1.41.10 → 1.43.1

package/lib/index.browser.cjs.js

@@ -8,7 +8,7 @@ var BN = require('bn.js');
 var bs58 = require('bs58');
 var borsh = require('borsh');
 var BufferLayout = require('@solana/buffer-layout');
-var bufferLayoutUtils = require('@solana/buffer-layout-utils');
+var bigintBuffer = require('bigint-buffer');
 var superstruct = require('superstruct');
 var rpcWebsockets = require('rpc-websockets');
 var RpcClient = require('jayson/lib/client/browser');
@@ -2828,8 +2828,6 @@ class Transaction {
     const message = this._compile();
 
     this._partialSign(message, ...uniqueSigners);
-
-    this._verifySignatures(message.serialize(), true);
   }
   /**
    * Partially sign a transaction with the specified accounts. All accounts must
@@ -3209,6 +3207,38 @@ class NonceAccount {
 
 }
 
+const encodeDecode = layout => {
+  const decode = layout.decode.bind(layout);
+  const encode = layout.encode.bind(layout);
+  return {
+    decode,
+    encode
+  };
+};
+
+const bigInt = length => property => {
+  const layout = BufferLayout.blob(length, property);
+  const {
+    encode,
+    decode
+  } = encodeDecode(layout);
+  const bigIntLayout = layout;
+
+  bigIntLayout.decode = (buffer$1, offset) => {
+    const src = decode(buffer$1, offset);
+    return bigintBuffer.toBigIntLE(buffer.Buffer.from(src));
+  };
+
+  bigIntLayout.encode = (bigInt, buffer, offset) => {
+    const src = bigintBuffer.toBufferLE(bigInt, length);
+    return encode(src, buffer, offset);
+  };
+
+  return bigIntLayout;
+};
+
+const u64 = bigInt(8);
+
 /**
  * Create account system transaction params
  */
@@ -3510,7 +3540,7 @@ const SYSTEM_INSTRUCTION_LAYOUTS = Object.freeze({
   },
   Transfer: {
     index: 2,
-    layout: BufferLayout__namespace.struct([BufferLayout__namespace.u32('instruction'), bufferLayoutUtils.u64('lamports')])
+    layout: BufferLayout__namespace.struct([BufferLayout__namespace.u32('instruction'), u64('lamports')])
   },
   CreateWithSeed: {
     index: 3,
@@ -3546,7 +3576,7 @@ const SYSTEM_INSTRUCTION_LAYOUTS = Object.freeze({
   },
   TransferWithSeed: {
     index: 11,
-    layout: BufferLayout__namespace.struct([BufferLayout__namespace.u32('instruction'), bufferLayoutUtils.u64('lamports'), rustString('seed'), publicKey('programId')])
+    layout: BufferLayout__namespace.struct([BufferLayout__namespace.u32('instruction'), u64('lamports'), rustString('seed'), publicKey('programId')])
   }
 });
 /**
@@ -4187,6 +4217,34 @@ class ComputeBudgetInstruction {
       bytes
     };
   }
+  /**
+   * Decode set compute unit limit compute budget instruction and retrieve the instruction params.
+   */
+
+
+  static decodeSetComputeUnitLimit(instruction) {
+    this.checkProgramId(instruction.programId);
+    const {
+      units
+    } = decodeData(COMPUTE_BUDGET_INSTRUCTION_LAYOUTS.SetComputeUnitLimit, instruction.data);
+    return {
+      units
+    };
+  }
+  /**
+   * Decode set compute unit price compute budget instruction and retrieve the instruction params.
+   */
+
+
+  static decodeSetComputeUnitPrice(instruction) {
+    this.checkProgramId(instruction.programId);
+    const {
+      microLamports
+    } = decodeData(COMPUTE_BUDGET_INSTRUCTION_LAYOUTS.SetComputeUnitPrice, instruction.data);
+    return {
+      microLamports
+    };
+  }
   /**
    * @internal
    */
@@ -4215,6 +4273,14 @@ const COMPUTE_BUDGET_INSTRUCTION_LAYOUTS = Object.freeze({
   RequestHeapFrame: {
     index: 1,
     layout: BufferLayout__namespace.struct([BufferLayout__namespace.u8('instruction'), BufferLayout__namespace.u32('bytes')])
+  },
+  SetComputeUnitLimit: {
+    index: 2,
+    layout: BufferLayout__namespace.struct([BufferLayout__namespace.u8('instruction'), BufferLayout__namespace.u32('units')])
+  },
+  SetComputeUnitPrice: {
+    index: 3,
+    layout: BufferLayout__namespace.struct([BufferLayout__namespace.u8('instruction'), u64('microLamports')])
   }
 });
 /**
@@ -4251,6 +4317,28 @@ class ComputeBudgetProgram {
     });
   }
 
+  static setComputeUnitLimit(params) {
+    const type = COMPUTE_BUDGET_INSTRUCTION_LAYOUTS.SetComputeUnitLimit;
+    const data = encodeData(type, params);
+    return new TransactionInstruction({
+      keys: [],
+      programId: this.programId,
+      data
+    });
+  }
+
+  static setComputeUnitPrice(params) {
+    const type = COMPUTE_BUDGET_INSTRUCTION_LAYOUTS.SetComputeUnitPrice;
+    const data = encodeData(type, {
+      microLamports: BigInt(params.microLamports)
+    });
+    return new TransactionInstruction({
+      keys: [],
+      programId: this.programId,
+      data
+    });
+  }
+
 }
 ComputeBudgetProgram.programId = new PublicKey('ComputeBudget111111111111111111111111111111');
 
@@ -6029,7 +6117,7 @@ class Connection {
     this._disableBlockhashCaching = false;
     this._pollingBlockhash = false;
     this._blockhashInfo = {
-      recentBlockhash: null,
+      latestBlockhash: null,
       lastFetch: 0,
       transactionSignatures: [],
       simulatedSignatures: []
@@ -6992,7 +7080,7 @@ class Connection {
   }
   /**
    * Fetch the latest blockhash from the cluster
-   * @return {Promise<{blockhash: Blockhash, lastValidBlockHeight: number}>}
+   * @return {Promise<BlockhashWithExpiryBlockHeight>}
    */
 
 
@@ -7006,7 +7094,7 @@ class Connection {
   }
   /**
    * Fetch the latest blockhash from the cluster
-   * @return {Promise<{blockhash: Blockhash, lastValidBlockHeight: number}>}
+   * @return {Promise<BlockhashWithExpiryBlockHeight>}
    */
 
 
@@ -7589,7 +7677,7 @@ class Connection {
    */
 
 
-  async _recentBlockhash(disableCache) {
+  async _blockhashWithExpiryBlockHeight(disableCache) {
     if (!disableCache) {
       // Wait for polling to finish
       while (this._pollingBlockhash) {
@@ -7600,8 +7688,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;
       }
     }
 
@@ -7617,20 +7705,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
 
 
@@ -7652,13 +7740,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
 
@@ -7671,7 +7757,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);
 
@@ -7755,7 +7843,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) {
@@ -10196,16 +10286,36 @@ VoteProgram.space = 3731;
  *
  * @param {Connection} connection
  * @param {Buffer} rawTransaction
+ * @param {BlockheightBasedTransactionConfirmationStrategy} 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)})`);