@solana/web3.js 1.72.0 → 1.72.1

package/lib/index.esm.js

@@ -8,13 +8,13 @@ import { serialize, deserialize, deserializeUnchecked } from 'borsh';
 import * as BufferLayout from '@solana/buffer-layout';
 import { blob } from '@solana/buffer-layout';
 import { toBigIntLE, toBufferLE } from 'bigint-buffer';
+import require$$1 from 'tty';
 import require$$0$1 from 'os';
-import require$$0$2 from 'tty';
 import require$$0 from 'util';
-import require$$0$3 from 'events';
-import require$$1 from 'path';
-import require$$0$4 from 'http';
-import require$$0$5, { Agent as Agent$1 } from 'https';
+import require$$0$2 from 'events';
+import require$$1$1 from 'path';
+import require$$0$3 from 'http';
+import require$$0$4, { Agent as Agent$1 } from 'https';
 import { coerce, instance, string, tuple, literal, unknown, union, type, optional, any, number, array, nullable, create, boolean, record, assert as assert$1 } from 'superstruct';
 import { Client } from 'rpc-websockets';
 import RpcClient from 'jayson/lib/client/browser';
@@ -765,6 +765,36 @@ class CompiledKeys {
 
 }
 
+const END_OF_BUFFER_ERROR_MESSAGE = 'Reached end of buffer unexpectedly';
+/**
+ * Delegates to `Array#shift`, but throws if the array is zero-length.
+ */
+
+function guardedShift(byteArray) {
+  if (byteArray.length === 0) {
+    throw new Error(END_OF_BUFFER_ERROR_MESSAGE);
+  }
+
+  return byteArray.shift();
+}
+/**
+ * Delegates to `Array#splice`, but throws if the section being spliced out extends past the end of
+ * the array.
+ */
+
+function guardedSplice(byteArray, ...args) {
+  var _args$;
+
+  const [start] = args;
+
+  if (args.length === 2 // Implies that `deleteCount` was supplied
+  ? start + ((_args$ = args[1]) !== null && _args$ !== void 0 ? _args$ : 0) > byteArray.length : start >= byteArray.length) {
+    throw new Error(END_OF_BUFFER_ERROR_MESSAGE);
+  }
+
+  return byteArray.splice(...args);
+}
+
 /**
  * An instruction to execute by a program
  *
@@ -916,37 +946,33 @@ class Message {
   static from(buffer) {
     // Slice up wire data
     let byteArray = [...buffer];
-    const numRequiredSignatures = byteArray.shift();
+    const numRequiredSignatures = guardedShift(byteArray);
 
     if (numRequiredSignatures !== (numRequiredSignatures & VERSION_PREFIX_MASK)) {
       throw new Error('Versioned messages must be deserialized with VersionedMessage.deserialize()');
     }
 
-    const numReadonlySignedAccounts = byteArray.shift();
-    const numReadonlyUnsignedAccounts = byteArray.shift();
+    const numReadonlySignedAccounts = guardedShift(byteArray);
+    const numReadonlyUnsignedAccounts = guardedShift(byteArray);
     const accountCount = decodeLength(byteArray);
     let accountKeys = [];
 
     for (let i = 0; i < accountCount; i++) {
-      const account = byteArray.slice(0, PUBLIC_KEY_LENGTH);
-      byteArray = byteArray.slice(PUBLIC_KEY_LENGTH);
+      const account = guardedSplice(byteArray, 0, PUBLIC_KEY_LENGTH);
       accountKeys.push(new PublicKey(Buffer.from(account)));
     }
 
-    const recentBlockhash = byteArray.slice(0, PUBLIC_KEY_LENGTH);
-    byteArray = byteArray.slice(PUBLIC_KEY_LENGTH);
+    const recentBlockhash = guardedSplice(byteArray, 0, PUBLIC_KEY_LENGTH);
     const instructionCount = decodeLength(byteArray);
     let instructions = [];
 
     for (let i = 0; i < instructionCount; i++) {
-      const programIdIndex = byteArray.shift();
+      const programIdIndex = guardedShift(byteArray);
       const accountCount = decodeLength(byteArray);
-      const accounts = byteArray.slice(0, accountCount);
-      byteArray = byteArray.slice(accountCount);
+      const accounts = guardedSplice(byteArray, 0, accountCount);
       const dataLength = decodeLength(byteArray);
-      const dataSlice = byteArray.slice(0, dataLength);
+      const dataSlice = guardedSplice(byteArray, 0, dataLength);
       const data = bs58.encode(Buffer.from(dataSlice));
-      byteArray = byteArray.slice(dataLength);
       instructions.push({
         programIdIndex,
         accounts,
@@ -1182,33 +1208,33 @@ class MessageV0 {
 
   static deserialize(serializedMessage) {
     let byteArray = [...serializedMessage];
-    const prefix = byteArray.shift();
+    const prefix = guardedShift(byteArray);
     const maskedPrefix = prefix & VERSION_PREFIX_MASK;
     assert(prefix !== maskedPrefix, `Expected versioned message but received legacy message`);
     const version = maskedPrefix;
     assert(version === 0, `Expected versioned message with version 0 but found version ${version}`);
     const header = {
-      numRequiredSignatures: byteArray.shift(),
-      numReadonlySignedAccounts: byteArray.shift(),
-      numReadonlyUnsignedAccounts: byteArray.shift()
+      numRequiredSignatures: guardedShift(byteArray),
+      numReadonlySignedAccounts: guardedShift(byteArray),
+      numReadonlyUnsignedAccounts: guardedShift(byteArray)
     };
     const staticAccountKeys = [];
     const staticAccountKeysLength = decodeLength(byteArray);
 
     for (let i = 0; i < staticAccountKeysLength; i++) {
-      staticAccountKeys.push(new PublicKey(byteArray.splice(0, PUBLIC_KEY_LENGTH)));
+      staticAccountKeys.push(new PublicKey(guardedSplice(byteArray, 0, PUBLIC_KEY_LENGTH)));
     }
 
-    const recentBlockhash = bs58.encode(byteArray.splice(0, PUBLIC_KEY_LENGTH));
+    const recentBlockhash = bs58.encode(guardedSplice(byteArray, 0, PUBLIC_KEY_LENGTH));
     const instructionCount = decodeLength(byteArray);
     const compiledInstructions = [];
 
     for (let i = 0; i < instructionCount; i++) {
-      const programIdIndex = byteArray.shift();
+      const programIdIndex = guardedShift(byteArray);
       const accountKeyIndexesLength = decodeLength(byteArray);
-      const accountKeyIndexes = byteArray.splice(0, accountKeyIndexesLength);
+      const accountKeyIndexes = guardedSplice(byteArray, 0, accountKeyIndexesLength);
       const dataLength = decodeLength(byteArray);
-      const data = new Uint8Array(byteArray.splice(0, dataLength));
+      const data = new Uint8Array(guardedSplice(byteArray, 0, dataLength));
       compiledInstructions.push({
         programIdIndex,
         accountKeyIndexes,
@@ -1220,11 +1246,11 @@ class MessageV0 {
     const addressTableLookups = [];
 
     for (let i = 0; i < addressTableLookupsCount; i++) {
-      const accountKey = new PublicKey(byteArray.splice(0, PUBLIC_KEY_LENGTH));
+      const accountKey = new PublicKey(guardedSplice(byteArray, 0, PUBLIC_KEY_LENGTH));
       const writableIndexesLength = decodeLength(byteArray);
-      const writableIndexes = byteArray.splice(0, writableIndexesLength);
+      const writableIndexes = guardedSplice(byteArray, 0, writableIndexesLength);
       const readonlyIndexesLength = decodeLength(byteArray);
-      const readonlyIndexes = byteArray.splice(0, readonlyIndexesLength);
+      const readonlyIndexes = guardedSplice(byteArray, 0, readonlyIndexesLength);
       addressTableLookups.push({
         accountKey,
         writableIndexes,
@@ -1966,8 +1992,7 @@ class Transaction {
     let signatures = [];
 
     for (let i = 0; i < signatureCount; i++) {
-      const signature = byteArray.slice(0, SIGNATURE_LENGTH_IN_BYTES);
-      byteArray = byteArray.slice(SIGNATURE_LENGTH_IN_BYTES);
+      const signature = guardedSplice(byteArray, 0, SIGNATURE_LENGTH_IN_BYTES);
       signatures.push(bs58.encode(Buffer.from(signature)));
     }
 
@@ -2165,7 +2190,7 @@ class VersionedTransaction {
     const signaturesLength = decodeLength(byteArray);
 
     for (let i = 0; i < signaturesLength; i++) {
-      signatures.push(new Uint8Array(byteArray.splice(0, SIGNATURE_LENGTH_IN_BYTES)));
+      signatures.push(new Uint8Array(guardedSplice(byteArray, 0, SIGNATURE_LENGTH_IN_BYTES)));
     }
 
     const message = VersionedMessage.deserialize(new Uint8Array(byteArray));
@@ -3338,7 +3363,7 @@ var y = d * 365.25;
  * @api public
  */
 
-var ms$2 = function(val, options) {
+var ms$3 = function (val, options) {
   options = options || {};
   var type = typeof val;
   if (type === 'string' && val.length > 0) {
@@ -3487,11 +3512,11 @@ function plural(ms, msAbs, n, name) {
  */
 
 var util = require$$0;
-var ms$1 = ms$2;
+var ms$2 = ms$3;
 
 var humanizeMs = function (t) {
   if (typeof t === 'number') return t;
-  var r = ms$1(t);
+  var r = ms$2(t);
   if (r === undefined) {
     var err = new Error(util.format('humanize-ms(%j) result undefined', t));
     console.warn(err.stack);
@@ -3503,6 +3528,177 @@ var src = {exports: {}};
 
 var browser = {exports: {}};
 
+/**
+ * Helpers.
+ */
+
+var ms$1;
+var hasRequiredMs;
+
+function requireMs () {
+	if (hasRequiredMs) return ms$1;
+	hasRequiredMs = 1;
+	var s = 1000;
+	var m = s * 60;
+	var h = m * 60;
+	var d = h * 24;
+	var w = d * 7;
+	var y = d * 365.25;
+
+	/**
+	 * Parse or format the given `val`.
+	 *
+	 * Options:
+	 *
+	 *  - `long` verbose formatting [false]
+	 *
+	 * @param {String|Number} val
+	 * @param {Object} [options]
+	 * @throws {Error} throw an error if val is not a non-empty string or a number
+	 * @return {String|Number}
+	 * @api public
+	 */
+
+	ms$1 = function(val, options) {
+	  options = options || {};
+	  var type = typeof val;
+	  if (type === 'string' && val.length > 0) {
+	    return parse(val);
+	  } else if (type === 'number' && isFinite(val)) {
+	    return options.long ? fmtLong(val) : fmtShort(val);
+	  }
+	  throw new Error(
+	    'val is not a non-empty string or a valid number. val=' +
+	      JSON.stringify(val)
+	  );
+	};
+
+	/**
+	 * Parse the given `str` and return milliseconds.
+	 *
+	 * @param {String} str
+	 * @return {Number}
+	 * @api private
+	 */
+
+	function parse(str) {
+	  str = String(str);
+	  if (str.length > 100) {
+	    return;
+	  }
+	  var match = /^(-?(?:\d+)?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)?$/i.exec(
+	    str
+	  );
+	  if (!match) {
+	    return;
+	  }
+	  var n = parseFloat(match[1]);
+	  var type = (match[2] || 'ms').toLowerCase();
+	  switch (type) {
+	    case 'years':
+	    case 'year':
+	    case 'yrs':
+	    case 'yr':
+	    case 'y':
+	      return n * y;
+	    case 'weeks':
+	    case 'week':
+	    case 'w':
+	      return n * w;
+	    case 'days':
+	    case 'day':
+	    case 'd':
+	      return n * d;
+	    case 'hours':
+	    case 'hour':
+	    case 'hrs':
+	    case 'hr':
+	    case 'h':
+	      return n * h;
+	    case 'minutes':
+	    case 'minute':
+	    case 'mins':
+	    case 'min':
+	    case 'm':
+	      return n * m;
+	    case 'seconds':
+	    case 'second':
+	    case 'secs':
+	    case 'sec':
+	    case 's':
+	      return n * s;
+	    case 'milliseconds':
+	    case 'millisecond':
+	    case 'msecs':
+	    case 'msec':
+	    case 'ms':
+	      return n;
+	    default:
+	      return undefined;
+	  }
+	}
+
+	/**
+	 * Short format for `ms`.
+	 *
+	 * @param {Number} ms
+	 * @return {String}
+	 * @api private
+	 */
+
+	function fmtShort(ms) {
+	  var msAbs = Math.abs(ms);
+	  if (msAbs >= d) {
+	    return Math.round(ms / d) + 'd';
+	  }
+	  if (msAbs >= h) {
+	    return Math.round(ms / h) + 'h';
+	  }
+	  if (msAbs >= m) {
+	    return Math.round(ms / m) + 'm';
+	  }
+	  if (msAbs >= s) {
+	    return Math.round(ms / s) + 's';
+	  }
+	  return ms + 'ms';
+	}
+
+	/**
+	 * Long format for `ms`.
+	 *
+	 * @param {Number} ms
+	 * @return {String}
+	 * @api private
+	 */
+
+	function fmtLong(ms) {
+	  var msAbs = Math.abs(ms);
+	  if (msAbs >= d) {
+	    return plural(ms, msAbs, d, 'day');
+	  }
+	  if (msAbs >= h) {
+	    return plural(ms, msAbs, h, 'hour');
+	  }
+	  if (msAbs >= m) {
+	    return plural(ms, msAbs, m, 'minute');
+	  }
+	  if (msAbs >= s) {
+	    return plural(ms, msAbs, s, 'second');
+	  }
+	  return ms + ' ms';
+	}
+
+	/**
+	 * Pluralization helper.
+	 */
+
+	function plural(ms, msAbs, n, name) {
+	  var isPlural = msAbs >= n * 1.5;
+	  return Math.round(ms / n) + ' ' + name + (isPlural ? 's' : '');
+	}
+	return ms$1;
+}
+
 var common;
 var hasRequiredCommon;
 
@@ -3521,7 +3717,7 @@ function requireCommon () {
 		createDebug.disable = disable;
 		createDebug.enable = enable;
 		createDebug.enabled = enabled;
-		createDebug.humanize = ms$2;
+		createDebug.humanize = requireMs();
 		createDebug.destroy = destroy;
 
 		Object.keys(env).forEach(key => {
@@ -4072,12 +4268,12 @@ var hasRequiredHasFlag;
 function requireHasFlag () {
 	if (hasRequiredHasFlag) return hasFlag;
 	hasRequiredHasFlag = 1;
-	hasFlag = (flag, argv) => {
-		argv = argv || process.argv;
+
+	hasFlag = (flag, argv = process.argv) => {
 		const prefix = flag.startsWith('-') ? '' : (flag.length === 1 ? '-' : '--');
-		const pos = argv.indexOf(prefix + flag);
-		const terminatorPos = argv.indexOf('--');
-		return pos !== -1 && (terminatorPos === -1 ? true : pos < terminatorPos);
+		const position = argv.indexOf(prefix + flag);
+		const terminatorPosition = argv.indexOf('--');
+		return position !== -1 && (terminatorPosition === -1 || position < terminatorPosition);
 	};
 	return hasFlag;
 }
@@ -4089,23 +4285,32 @@ function requireSupportsColor () {
 	if (hasRequiredSupportsColor) return supportsColor_1;
 	hasRequiredSupportsColor = 1;
 	const os = require$$0$1;
+	const tty = require$$1;
 	const hasFlag = requireHasFlag();
 
-	const env = process.env;
+	const {env} = process;
 
 	let forceColor;
 	if (hasFlag('no-color') ||
 		hasFlag('no-colors') ||
-		hasFlag('color=false')) {
-		forceColor = false;
+		hasFlag('color=false') ||
+		hasFlag('color=never')) {
+		forceColor = 0;
 	} else if (hasFlag('color') ||
 		hasFlag('colors') ||
 		hasFlag('color=true') ||
 		hasFlag('color=always')) {
-		forceColor = true;
+		forceColor = 1;
 	}
+
 	if ('FORCE_COLOR' in env) {
-		forceColor = env.FORCE_COLOR.length === 0 || parseInt(env.FORCE_COLOR, 10) !== 0;
+		if (env.FORCE_COLOR === 'true') {
+			forceColor = 1;
+		} else if (env.FORCE_COLOR === 'false') {
+			forceColor = 0;
+		} else {
+			forceColor = env.FORCE_COLOR.length === 0 ? 1 : Math.min(parseInt(env.FORCE_COLOR, 10), 3);
+		}
 	}
 
 	function translateLevel(level) {
@@ -4121,8 +4326,8 @@ function requireSupportsColor () {
 		};
 	}
 
-	function supportsColor(stream) {
-		if (forceColor === false) {
+	function supportsColor(haveStream, streamIsTTY) {
+		if (forceColor === 0) {
 			return 0;
 		}
 
@@ -4136,22 +4341,21 @@ function requireSupportsColor () {
 			return 2;
 		}
 
-		if (stream && !stream.isTTY && forceColor !== true) {
+		if (haveStream && !streamIsTTY && forceColor === undefined) {
 			return 0;
 		}
 
-		const min = forceColor ? 1 : 0;
+		const min = forceColor || 0;
+
+		if (env.TERM === 'dumb') {
+			return min;
+		}
 
 		if (process.platform === 'win32') {
-			// Node.js 7.5.0 is the first version of Node.js to include a patch to
-			// libuv that enables 256 color output on Windows. Anything earlier and it
-			// won't work. However, here we target Node.js 8 at minimum as it is an LTS
-			// release, and Node.js 7 is not. Windows 10 build 10586 is the first Windows
-			// release that supports 256 colors. Windows 10 build 14931 is the first release
-			// that supports 16m/TrueColor.
+			// Windows 10 build 10586 is the first Windows release that supports 256 colors.
+			// Windows 10 build 14931 is the first release that supports 16m/TrueColor.
 			const osRelease = os.release().split('.');
 			if (
-				Number(process.versions.node.split('.')[0]) >= 8 &&
 				Number(osRelease[0]) >= 10 &&
 				Number(osRelease[2]) >= 10586
 			) {
@@ -4162,7 +4366,7 @@ function requireSupportsColor () {
 		}
 
 		if ('CI' in env) {
-			if (['TRAVIS', 'CIRCLECI', 'APPVEYOR', 'GITLAB_CI'].some(sign => sign in env) || env.CI_NAME === 'codeship') {
+			if (['TRAVIS', 'CIRCLECI', 'APPVEYOR', 'GITLAB_CI', 'GITHUB_ACTIONS', 'BUILDKITE'].some(sign => sign in env) || env.CI_NAME === 'codeship') {
 				return 1;
 			}
 
@@ -4201,22 +4405,18 @@ function requireSupportsColor () {
 			return 1;
 		}
 
-		if (env.TERM === 'dumb') {
-			return min;
-		}
-
 		return min;
 	}
 
 	function getSupportLevel(stream) {
-		const level = supportsColor(stream);
+		const level = supportsColor(stream, stream && stream.isTTY);
 		return translateLevel(level);
 	}
 
 	supportsColor_1 = {
 		supportsColor: getSupportLevel,
-		stdout: getSupportLevel(process.stdout),
-		stderr: getSupportLevel(process.stderr)
+		stdout: translateLevel(supportsColor(true, tty.isatty(1))),
+		stderr: translateLevel(supportsColor(true, tty.isatty(2)))
 	};
 	return supportsColor_1;
 }
@@ -4231,7 +4431,7 @@ function requireNode () {
 	if (hasRequiredNode) return node.exports;
 	hasRequiredNode = 1;
 	(function (module, exports) {
-		const tty = require$$0$2;
+		const tty = require$$1;
 		const util = require$$0;
 
 		/**
@@ -4663,7 +4863,7 @@ function requireEventListenerCount () {
 	 * @private
 	 */
 
-	var EventEmitter = require$$0$3.EventEmitter;
+	var EventEmitter = require$$0$2.EventEmitter;
 
 	/**
 	 * Module exports.
@@ -4743,7 +4943,7 @@ function requireEventListenerCount () {
 
 var callSiteToString = compat.exports.callSiteToString;
 var eventListenerCount = compat.exports.eventListenerCount;
-var relative = require$$1.relative;
+var relative = require$$1$1.relative;
 
 /**
  * Module exports.
@@ -5266,7 +5466,7 @@ var constants = {
   SOCKET_REQUEST_FINISHED_COUNT: Symbol('agentkeepalive#socketRequestFinishedCount'),
 };
 
-const OriginalAgent = require$$0$4.Agent;
+const OriginalAgent = require$$0$3.Agent;
 const ms = humanizeMs;
 const debug = src.exports('agentkeepalive');
 const deprecate = depd_1('agentkeepalive');
@@ -5663,7 +5863,7 @@ function inspect(obj) {
   return res;
 }
 
-const OriginalHttpsAgent = require$$0$5.Agent;
+const OriginalHttpsAgent = require$$0$4.Agent;
 const HttpAgent = agent;
 const {
   INIT_SOCKET,
@@ -7141,7 +7341,7 @@ const LogsNotificationResult = type({
 
 /** @internal */
 const COMMON_HTTP_HEADERS = {
-  'solana-client': `js/${(_process$env$npm_pack = "0.0.0-development") !== null && _process$env$npm_pack !== void 0 ? _process$env$npm_pack : 'UNKNOWN'}`
+  'solana-client': `js/${(_process$env$npm_pack = "1.72.1") !== null && _process$env$npm_pack !== void 0 ? _process$env$npm_pack : 'UNKNOWN'}`
 };
 /**
  * A connection to a fullnode JSON RPC endpoint
@@ -12574,10 +12774,8 @@ class ValidatorInfo {
     const configKeys = [];
 
     for (let i = 0; i < 2; i++) {
-      const publicKey = new PublicKey(byteArray.slice(0, PUBLIC_KEY_LENGTH));
-      byteArray = byteArray.slice(PUBLIC_KEY_LENGTH);
-      const isSigner = byteArray.slice(0, 1)[0] === 1;
-      byteArray = byteArray.slice(1);
+      const publicKey = new PublicKey(guardedSplice(byteArray, 0, PUBLIC_KEY_LENGTH));
+      const isSigner = guardedShift(byteArray) === 1;
       configKeys.push({
         publicKey,
         isSigner