@solana/web3.js 1.42.0 → 1.43.2

package/lib/index.d.ts

@@ -1,7 +1,7 @@
 /// <reference types="node" />
 declare module '@solana/web3.js' {
   import {Buffer} from 'buffer';
-  import crossFetch from 'cross-fetch';
+  import * as nodeFetch from 'node-fetch';
 
   export class Struct {
     constructor(properties: any);
@@ -179,6 +179,11 @@ declare module '@solana/web3.js' {
     getSlotsInEpoch(epoch: number): number;
   }
 
+  export function export_default(
+    input: nodeFetch.RequestInfo,
+    init?: nodeFetch.RequestInit,
+  ): Promise<nodeFetch.Response>;
+
   /**
    * Calculator for transaction fees.
    */
@@ -633,7 +638,7 @@ declare module '@solana/web3.js' {
    * A strategy for confirming transactions that uses the last valid
    * block height for a given blockhash to check for transaction expiration.
    */
-  export type BlockheightBasedTransactionConfimationStrategy = {
+  export type BlockheightBasedTransactionConfirmationStrategy = {
     signature: TransactionSignature;
   } & BlockhashWithExpiryBlockHeight;
   /**
@@ -1444,13 +1449,17 @@ declare module '@solana/web3.js' {
   export type HttpHeaders = {
     [header: string]: string;
   };
+  /**
+   * The type of the JavaScript `fetch()` API
+   */
+  export type FetchFn = typeof export_default;
   /**
    * A callback used to augment the outgoing HTTP request
    */
   export type FetchMiddleware = (
-    url: string,
-    options: any,
-    fetch: (modifiedUrl: string, modifiedOptions: any) => void,
+    info: Parameters<FetchFn>[0],
+    init: Parameters<FetchFn>[1],
+    fetch: (...a: Parameters<FetchFn>) => void,
   ) => void;
   /**
    * Configuration for instantiating a Connection
@@ -1463,7 +1472,7 @@ declare module '@solana/web3.js' {
     /** Optional HTTP headers object */
     httpHeaders?: HttpHeaders;
     /** Optional custom fetch function */
-    fetch?: typeof crossFetch;
+    fetch?: FetchFn;
     /** Optional fetch middleware callback */
     fetchMiddleware?: FetchMiddleware;
     /** Optional Disable retrying calls when server responds with HTTP 429 (Too Many Requests) */
@@ -1659,7 +1668,7 @@ declare module '@solana/web3.js' {
       }>
     >;
     confirmTransaction(
-      strategy: BlockheightBasedTransactionConfimationStrategy,
+      strategy: BlockheightBasedTransactionConfirmationStrategy,
       commitment?: Commitment,
     ): Promise<RpcResponseAndContext<SignatureResult>>;
     /** @deprecated Instead, call `confirmTransaction` using a `TransactionConfirmationConfig` */
@@ -2226,20 +2235,34 @@ declare module '@solana/web3.js' {
     static decodeRequestHeapFrame(
       instruction: TransactionInstruction,
     ): RequestHeapFrameParams;
+    /**
+     * Decode set compute unit limit compute budget instruction and retrieve the instruction params.
+     */
+    static decodeSetComputeUnitLimit(
+      instruction: TransactionInstruction,
+    ): SetComputeUnitLimitParams;
+    /**
+     * Decode set compute unit price compute budget instruction and retrieve the instruction params.
+     */
+    static decodeSetComputeUnitPrice(
+      instruction: TransactionInstruction,
+    ): SetComputeUnitPriceParams;
   }
   /**
    * An enumeration of valid ComputeBudgetInstructionType's
    */
   export type ComputeBudgetInstructionType =
     | 'RequestUnits'
-    | 'RequestHeapFrame';
+    | 'RequestHeapFrame'
+    | 'SetComputeUnitLimit'
+    | 'SetComputeUnitPrice';
   /**
    * Request units instruction params
    */
   interface RequestUnitsParams {
     /** Units to request for transaction-wide compute */
     units: number;
-    /** Additional fee to pay */
+    /** Prioritization fee lamports */
     additionalFee: number;
   }
   /**
@@ -2249,6 +2272,20 @@ declare module '@solana/web3.js' {
     /** Requested transaction-wide program heap size in bytes. Must be multiple of 1024. Applies to each program, including CPIs. */
     bytes: number;
   };
+  /**
+   * Set compute unit limit instruction params
+   */
+  interface SetComputeUnitLimitParams {
+    /** Transaction-wide compute unit limit */
+    units: number;
+  }
+  /**
+   * Set compute unit price instruction params
+   */
+  interface SetComputeUnitPriceParams {
+    /** Transaction compute unit price used for prioritization fees */
+    microLamports: number | bigint;
+  }
   /**
    * Factory class for transaction instructions to interact with the Compute Budget program
    */
@@ -2261,6 +2298,12 @@ declare module '@solana/web3.js' {
     static requestHeapFrame(
       params: RequestHeapFrameParams,
     ): TransactionInstruction;
+    static setComputeUnitLimit(
+      params: SetComputeUnitLimitParams,
+    ): TransactionInstruction;
+    static setComputeUnitPrice(
+      params: SetComputeUnitPriceParams,
+    ): TransactionInstruction;
   }
 
   /**
@@ -3352,14 +3395,14 @@ declare module '@solana/web3.js' {
    *
    * @param {Connection} connection
    * @param {Buffer} rawTransaction
-   * @param {BlockheightBasedTransactionConfimationStrategy} confirmationStrategy
+   * @param {BlockheightBasedTransactionConfirmationStrategy} confirmationStrategy
    * @param {ConfirmOptions} [options]
    * @returns {Promise<TransactionSignature>}
    */
   export function sendAndConfirmRawTransaction(
     connection: Connection,
     rawTransaction: Buffer,
-    confirmationStrategy: BlockheightBasedTransactionConfimationStrategy,
+    confirmationStrategy: BlockheightBasedTransactionConfirmationStrategy,
     options?: ConfirmOptions,
   ): Promise<TransactionSignature>;
   /**

package/lib/index.esm.js

@@ -4,13 +4,14 @@ import BN from 'bn.js';
 import bs58 from 'bs58';
 import { serialize, deserialize, deserializeUnchecked } from 'borsh';
 import * as BufferLayout from '@solana/buffer-layout';
-import { u64 } from '@solana/buffer-layout-utils';
-import crossFetch from 'cross-fetch';
+import { blob } from '@solana/buffer-layout';
+import { toBigIntLE, toBufferLE } from 'bigint-buffer';
 import { coerce, instance, string, tuple, literal, unknown, union, type, optional, any, number, array, nullable, create, boolean, record, assert as assert$7 } from 'superstruct';
 import { Client } from 'rpc-websockets';
 import RpcClient from 'jayson/lib/client/browser';
 import http from 'http';
 import https from 'https';
+import * as nodeFetch from 'node-fetch';
 import secp256k1 from 'secp256k1';
 import sha3 from 'js-sha3';
 
@@ -44,43 +45,52 @@ var inherits$1 = {exports: {}};
 
 var inherits_browser = {exports: {}};
 
-if (typeof Object.create === 'function') {
-  // implementation from standard node.js 'util' module
-  inherits_browser.exports = function inherits(ctor, superCtor) {
-    if (superCtor) {
-      ctor.super_ = superCtor;
-      ctor.prototype = Object.create(superCtor.prototype, {
-        constructor: {
-          value: ctor,
-          enumerable: false,
-          writable: true,
-          configurable: true
-        }
-      });
-    }
-  };
-} else {
-  // old school shim for old browsers
-  inherits_browser.exports = function inherits(ctor, superCtor) {
-    if (superCtor) {
-      ctor.super_ = superCtor;
-      var TempCtor = function () {};
-      TempCtor.prototype = superCtor.prototype;
-      ctor.prototype = new TempCtor();
-      ctor.prototype.constructor = ctor;
-    }
-  };
+var hasRequiredInherits_browser;
+
+function requireInherits_browser () {
+	if (hasRequiredInherits_browser) return inherits_browser.exports;
+	hasRequiredInherits_browser = 1;
+	if (typeof Object.create === 'function') {
+	  // implementation from standard node.js 'util' module
+	  inherits_browser.exports = function inherits(ctor, superCtor) {
+	    if (superCtor) {
+	      ctor.super_ = superCtor;
+	      ctor.prototype = Object.create(superCtor.prototype, {
+	        constructor: {
+	          value: ctor,
+	          enumerable: false,
+	          writable: true,
+	          configurable: true
+	        }
+	      });
+	    }
+	  };
+	} else {
+	  // old school shim for old browsers
+	  inherits_browser.exports = function inherits(ctor, superCtor) {
+	    if (superCtor) {
+	      ctor.super_ = superCtor;
+	      var TempCtor = function () {};
+	      TempCtor.prototype = superCtor.prototype;
+	      ctor.prototype = new TempCtor();
+	      ctor.prototype.constructor = ctor;
+	    }
+	  };
+	}
+	return inherits_browser.exports;
 }
 
-try {
-  var util = require('util');
-  /* istanbul ignore next */
-  if (typeof util.inherits !== 'function') throw '';
-  inherits$1.exports = util.inherits;
-} catch (e) {
-  /* istanbul ignore next */
-  inherits$1.exports = inherits_browser.exports;
-}
+(function (module) {
+	try {
+	  var util = require('util');
+	  /* istanbul ignore next */
+	  if (typeof util.inherits !== 'function') throw '';
+	  module.exports = util.inherits;
+	} catch (e) {
+	  /* istanbul ignore next */
+	  module.exports = requireInherits_browser();
+	}
+} (inherits$1));
 
 var assert$5 = minimalisticAssert;
 var inherits = inherits$1.exports;
@@ -1272,22 +1282,22 @@ Hmac.prototype.digest = function digest(enc) {
 };
 
 (function (exports) {
-var hash = exports;
-
-hash.utils = utils$9;
-hash.common = common$5;
-hash.sha = sha;
-hash.ripemd = ripemd;
-hash.hmac = hmac;
-
-// Proxy hash functions to the main object
-hash.sha1 = hash.sha.sha1;
-hash.sha256 = hash.sha.sha256;
-hash.sha224 = hash.sha.sha224;
-hash.sha384 = hash.sha.sha384;
-hash.sha512 = hash.sha.sha512;
-hash.ripemd160 = hash.ripemd.ripemd160;
-}(hash$1));
+	var hash = exports;
+
+	hash.utils = utils$9;
+	hash.common = common$5;
+	hash.sha = sha;
+	hash.ripemd = ripemd;
+	hash.hmac = hmac;
+
+	// Proxy hash functions to the main object
+	hash.sha1 = hash.sha.sha1;
+	hash.sha256 = hash.sha.sha256;
+	hash.sha224 = hash.sha.sha224;
+	hash.sha384 = hash.sha.sha384;
+	hash.sha512 = hash.sha.sha512;
+	hash.ripemd160 = hash.ripemd.ripemd160;
+} (hash$1));
 
 var hash = hash$1;
 
@@ -2805,8 +2815,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
@@ -3186,6 +3194,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 = blob(length, property);
+  const {
+    encode,
+    decode
+  } = encodeDecode(layout);
+  const bigIntLayout = layout;
+
+  bigIntLayout.decode = (buffer, offset) => {
+    const src = decode(buffer, offset);
+    return toBigIntLE(Buffer.from(src));
+  };
+
+  bigIntLayout.encode = (bigInt, buffer, offset) => {
+    const src = toBufferLE(bigInt, length);
+    return encode(src, buffer, offset);
+  };
+
+  return bigIntLayout;
+};
+
+const u64 = bigInt(8);
+
 /**
  * Create account system transaction params
  */
@@ -4164,6 +4204,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
    */
@@ -4192,6 +4260,14 @@ const COMPUTE_BUDGET_INSTRUCTION_LAYOUTS = Object.freeze({
   RequestHeapFrame: {
     index: 1,
     layout: BufferLayout.struct([BufferLayout.u8('instruction'), BufferLayout.u32('bytes')])
+  },
+  SetComputeUnitLimit: {
+    index: 2,
+    layout: BufferLayout.struct([BufferLayout.u8('instruction'), BufferLayout.u32('units')])
+  },
+  SetComputeUnitPrice: {
+    index: 3,
+    layout: BufferLayout.struct([BufferLayout.u8('instruction'), u64('microLamports')])
   }
 });
 /**
@@ -4228,6 +4304,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');
 
@@ -4461,6 +4559,11 @@ class SendTransactionError extends Error {
 
 }
 
+async function fetchImpl (input, init) {
+  const processedInput = typeof input === 'string' && input.slice(0, 2) === '//' ? 'https:' + input : input;
+  return await nodeFetch.default(processedInput, init);
+}
+
 // TODO: These constants should be removed in favor of reading them out of a
 // Syscall account
 
@@ -4710,7 +4813,7 @@ const BlockProductionResponseStruct = jsonRpcResultAndContext(type({
  */
 
 function createRpcClient(url, useHttps, httpHeaders, customFetch, fetchMiddleware, disableRetryOnRateLimit) {
-  const fetch = customFetch ? customFetch : crossFetch;
+  const fetch = customFetch ? customFetch : fetchImpl;
   let agentManager;
 
   {
@@ -4720,10 +4823,10 @@ function createRpcClient(url, useHttps, httpHeaders, customFetch, fetchMiddlewar
   let fetchWithMiddleware;
 
   if (fetchMiddleware) {
-    fetchWithMiddleware = async (url, options) => {
+    fetchWithMiddleware = async (info, init) => {
       const modifiedFetchArgs = await new Promise((resolve, reject) => {
         try {
-          fetchMiddleware(url, options, (modifiedUrl, modifiedOptions) => resolve([modifiedUrl, modifiedOptions]));
+          fetchMiddleware(info, init, (modifiedInfo, modifiedInit) => resolve([modifiedInfo, modifiedInit]));
         } catch (error) {
           reject(error);
         }
@@ -9669,7 +9772,7 @@ VoteProgram.space = 3731;
  *
  * @param {Connection} connection
  * @param {Buffer} rawTransaction
- * @param {BlockheightBasedTransactionConfimationStrategy} confirmationStrategy
+ * @param {BlockheightBasedTransactionConfirmationStrategy} confirmationStrategy
  * @param {ConfirmOptions} [options]
  * @returns {Promise<TransactionSignature>}
  */