@solana/web3.js 1.40.1 → 1.41.2

package/lib/index.iife.js

@@ -13761,6 +13761,16 @@ var solanaWeb3 = (function (exports) {
 	/** Factory for {@link Constant} values. */
 	Layout$1.constant = ((value, property) => new Constant(value, property));
 
+	/**
+	 * Maximum over-the-wire size of a Transaction
+	 *
+	 * 1280 is IPv6 minimum MTU
+	 * 40 bytes is the size of the IPv6 header
+	 * 8 bytes is the size of the fragment header
+	 */
+	const PACKET_DATA_SIZE = 1280 - 40 - 8;
+	const SIGNATURE_LENGTH_IN_BYTES = 64;
+
 	/**
 	 * Layout for a public key
 	 */
@@ -14020,20 +14030,8 @@ var solanaWeb3 = (function (exports) {
 
 	/**
 	 * Default (empty) signature
-	 *
-	 * Signatures are 64 bytes in length
 	 */
-	const DEFAULT_SIGNATURE = buffer.Buffer.alloc(64).fill(0);
-	/**
-	 * Maximum over-the-wire size of a Transaction
-	 *
-	 * 1280 is IPv6 minimum MTU
-	 * 40 bytes is the size of the IPv6 header
-	 * 8 bytes is the size of the fragment header
-	 */
-
-	const PACKET_DATA_SIZE = 1280 - 40 - 8;
-	const SIGNATURE_LENGTH = 64;
+	const DEFAULT_SIGNATURE = buffer.Buffer.alloc(SIGNATURE_LENGTH_IN_BYTES).fill(0);
 	/**
 	 * Account metadata used to define instructions
 	 */
@@ -14663,8 +14661,8 @@ var solanaWeb3 = (function (exports) {
 	    let signatures = [];
 
 	    for (let i = 0; i < signatureCount; i++) {
-	      const signature = byteArray.slice(0, SIGNATURE_LENGTH);
-	      byteArray = byteArray.slice(SIGNATURE_LENGTH);
+	      const signature = byteArray.slice(0, SIGNATURE_LENGTH_IN_BYTES);
+	      byteArray = byteArray.slice(SIGNATURE_LENGTH_IN_BYTES);
 	      signatures.push(bs58$1.encode(buffer.Buffer.from(signature)));
 	    }
 
@@ -15553,11 +15551,11 @@ var solanaWeb3 = (function (exports) {
 	}
 	SystemProgram.programId = new PublicKey('11111111111111111111111111111111');
 
-	// Keep program chunks under PACKET_DATA_SIZE, leaving enough room for the
 	// rest of the Transaction fields
 	//
 	// TODO: replace 300 with a proper constant for the size of the other
 	// Transaction fields
+
 	const CHUNK_SIZE = PACKET_DATA_SIZE - 300;
 	/**
 	 * Program loader interface
@@ -15757,6 +15755,136 @@ var solanaWeb3 = (function (exports) {
 
 	}
 
+	/**
+	 * Compute Budget Instruction class
+	 */
+
+	class ComputeBudgetInstruction {
+	  /**
+	   * @internal
+	   */
+	  constructor() {}
+	  /**
+	   * Decode a compute budget instruction and retrieve the instruction type.
+	   */
+
+
+	  static decodeInstructionType(instruction) {
+	    this.checkProgramId(instruction.programId);
+	    const instructionTypeLayout = u8('instruction');
+	    const typeIndex = instructionTypeLayout.decode(instruction.data);
+	    let type;
+
+	    for (const [ixType, layout] of Object.entries(COMPUTE_BUDGET_INSTRUCTION_LAYOUTS)) {
+	      if (layout.index == typeIndex) {
+	        type = ixType;
+	        break;
+	      }
+	    }
+
+	    if (!type) {
+	      throw new Error('Instruction type incorrect; not a ComputeBudgetInstruction');
+	    }
+
+	    return type;
+	  }
+	  /**
+	   * Decode request units compute budget instruction and retrieve the instruction params.
+	   */
+
+
+	  static decodeRequestUnits(instruction) {
+	    this.checkProgramId(instruction.programId);
+	    const {
+	      units,
+	      additionalFee
+	    } = decodeData(COMPUTE_BUDGET_INSTRUCTION_LAYOUTS.RequestUnits, instruction.data);
+	    return {
+	      units,
+	      additionalFee
+	    };
+	  }
+	  /**
+	   * Decode request heap frame compute budget instruction and retrieve the instruction params.
+	   */
+
+
+	  static decodeRequestHeapFrame(instruction) {
+	    this.checkProgramId(instruction.programId);
+	    const {
+	      bytes
+	    } = decodeData(COMPUTE_BUDGET_INSTRUCTION_LAYOUTS.RequestHeapFrame, instruction.data);
+	    return {
+	      bytes
+	    };
+	  }
+	  /**
+	   * @internal
+	   */
+
+
+	  static checkProgramId(programId) {
+	    if (!programId.equals(ComputeBudgetProgram.programId)) {
+	      throw new Error('invalid instruction; programId is not ComputeBudgetProgram');
+	    }
+	  }
+
+	}
+	/**
+	 * An enumeration of valid ComputeBudgetInstructionType's
+	 */
+
+	/**
+	 * An enumeration of valid ComputeBudget InstructionType's
+	 * @internal
+	 */
+	const COMPUTE_BUDGET_INSTRUCTION_LAYOUTS = Object.freeze({
+	  RequestUnits: {
+	    index: 0,
+	    layout: struct([u8('instruction'), u32('units'), u32('additionalFee')])
+	  },
+	  RequestHeapFrame: {
+	    index: 1,
+	    layout: struct([u8('instruction'), u32('bytes')])
+	  }
+	});
+	/**
+	 * Factory class for transaction instructions to interact with the Compute Budget program
+	 */
+
+	class ComputeBudgetProgram {
+	  /**
+	   * @internal
+	   */
+	  constructor() {}
+	  /**
+	   * Public key that identifies the Compute Budget program
+	   */
+
+
+	  static requestUnits(params) {
+	    const type = COMPUTE_BUDGET_INSTRUCTION_LAYOUTS.RequestUnits;
+	    const data = encodeData(type, params);
+	    return new TransactionInstruction({
+	      keys: [],
+	      programId: this.programId,
+	      data
+	    });
+	  }
+
+	  static requestHeapFrame(params) {
+	    const type = COMPUTE_BUDGET_INSTRUCTION_LAYOUTS.RequestHeapFrame;
+	    const data = encodeData(type, params);
+	    return new TransactionInstruction({
+	      keys: [],
+	      programId: this.programId,
+	      data
+	    });
+	  }
+
+	}
+	ComputeBudgetProgram.programId = new PublicKey('ComputeBudget111111111111111111111111111111');
+
 	var browserPonyfill = {exports: {}};
 
 	(function (module, exports) {
@@ -16318,6 +16446,82 @@ var solanaWeb3 = (function (exports) {
 
 	var crossFetch = /*@__PURE__*/getDefaultExportFromCjs(browserPonyfill.exports);
 
+	var objToString = Object.prototype.toString;
+	var objKeys = Object.keys || function(obj) {
+			var keys = [];
+			for (var name in obj) {
+				keys.push(name);
+			}
+			return keys;
+		};
+
+	function stringify$1(val, isArrayProp) {
+		var i, max, str, keys, key, propVal, toStr;
+		if (val === true) {
+			return "true";
+		}
+		if (val === false) {
+			return "false";
+		}
+		switch (typeof val) {
+			case "object":
+				if (val === null) {
+					return null;
+				} else if (val.toJSON && typeof val.toJSON === "function") {
+					return stringify$1(val.toJSON(), isArrayProp);
+				} else {
+					toStr = objToString.call(val);
+					if (toStr === "[object Array]") {
+						str = '[';
+						max = val.length - 1;
+						for(i = 0; i < max; i++) {
+							str += stringify$1(val[i], true) + ',';
+						}
+						if (max > -1) {
+							str += stringify$1(val[i], true);
+						}
+						return str + ']';
+					} else if (toStr === "[object Object]") {
+						// only object is left
+						keys = objKeys(val).sort();
+						max = keys.length;
+						str = "";
+						i = 0;
+						while (i < max) {
+							key = keys[i];
+							propVal = stringify$1(val[key], false);
+							if (propVal !== undefined) {
+								if (str) {
+									str += ',';
+								}
+								str += JSON.stringify(key) + ':' + propVal;
+							}
+							i++;
+						}
+						return '{' + str + '}';
+					} else {
+						return JSON.stringify(val);
+					}
+				}
+			case "function":
+			case "undefined":
+				return isArrayProp ? null : undefined;
+			case "string":
+				return JSON.stringify(val);
+			default:
+				return isFinite(val) ? val : null;
+		}
+	}
+
+	var fastStableStringify = function(val) {
+		var returnVal = stringify$1(val, false);
+		if (returnVal !== undefined) {
+			return ''+ returnVal;
+		}
+	};
+
+	var fastStableStringify$1 = fastStableStringify;
+
 	/**
 	 * A `StructFailure` represents a single specific failure in validation.
 	 */
@@ -16942,6 +17146,31 @@ var solanaWeb3 = (function (exports) {
 	module.exports = _interopRequireDefault, module.exports.__esModule = true, module.exports["default"] = module.exports;
 	}(interopRequireDefault));
 
+	var createClass = {exports: {}};
+
+	(function (module) {
+	function _defineProperties(target, props) {
+	  for (var i = 0; i < props.length; i++) {
+	    var descriptor = props[i];
+	    descriptor.enumerable = descriptor.enumerable || false;
+	    descriptor.configurable = true;
+	    if ("value" in descriptor) descriptor.writable = true;
+	    Object.defineProperty(target, descriptor.key, descriptor);
+	  }
+	}
+
+	function _createClass(Constructor, protoProps, staticProps) {
+	  if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+	  if (staticProps) _defineProperties(Constructor, staticProps);
+	  Object.defineProperty(Constructor, "prototype", {
+	    writable: false
+	  });
+	  return Constructor;
+	}
+
+	module.exports = _createClass, module.exports.__esModule = true, module.exports["default"] = module.exports;
+	}(createClass));
+
 	var classCallCheck = {exports: {}};
 
 	(function (module) {
@@ -17059,31 +17288,6 @@ var solanaWeb3 = (function (exports) {
 
 	var websocket_browser = {};
 
-	var createClass = {exports: {}};
-
-	(function (module) {
-	function _defineProperties(target, props) {
-	  for (var i = 0; i < props.length; i++) {
-	    var descriptor = props[i];
-	    descriptor.enumerable = descriptor.enumerable || false;
-	    descriptor.configurable = true;
-	    if ("value" in descriptor) descriptor.writable = true;
-	    Object.defineProperty(target, descriptor.key, descriptor);
-	  }
-	}
-
-	function _createClass(Constructor, protoProps, staticProps) {
-	  if (protoProps) _defineProperties(Constructor.prototype, protoProps);
-	  if (staticProps) _defineProperties(Constructor, staticProps);
-	  Object.defineProperty(Constructor, "prototype", {
-	    writable: false
-	  });
-	  return Constructor;
-	}
-
-	module.exports = _createClass, module.exports.__esModule = true, module.exports["default"] = module.exports;
-	}(createClass));
-
 	var eventemitter3 = {exports: {}};
 
 	(function (module) {
@@ -17452,7 +17656,7 @@ var solanaWeb3 = (function (exports) {
 
 	function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = (0, _getPrototypeOf2["default"])(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = (0, _getPrototypeOf2["default"])(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return (0, _possibleConstructorReturn2["default"])(this, result); }; }
 
-	function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }
+	function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
 
 	var WebSocketBrowserImpl = /*#__PURE__*/function (_EventEmitter) {
 	  (0, _inherits2["default"])(WebSocketBrowserImpl, _EventEmitter);
@@ -18353,215 +18557,6 @@ var solanaWeb3 = (function (exports) {
 	module.exports = _asyncToGenerator, module.exports.__esModule = true, module.exports["default"] = module.exports;
 	}(asyncToGenerator));
 
-	/*!
-	Copyright (C) 2013-2017 by Andrea Giammarchi - @WebReflection
-
-	Permission is hereby granted, free of charge, to any person obtaining a copy
-	of this software and associated documentation files (the "Software"), to deal
-	in the Software without restriction, including without limitation the rights
-	to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-	copies of the Software, and to permit persons to whom the Software is
-	furnished to do so, subject to the following conditions:
-
-	The above copyright notice and this permission notice shall be included in
-	all copies or substantial portions of the Software.
-
-	THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-	IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-	FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-	AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-	LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-	OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-	THE SOFTWARE.
-
-	*/
-
-	var
-	  // should be a not so common char
-	  // possibly one JSON does not encode
-	  // possibly one encodeURIComponent does not encode
-	  // right now this char is '~' but this might change in the future
-	  specialChar = '~',
-	  safeSpecialChar = '\\x' + (
-	    '0' + specialChar.charCodeAt(0).toString(16)
-	  ).slice(-2),
-	  escapedSafeSpecialChar = '\\' + safeSpecialChar,
-	  specialCharRG = new RegExp(safeSpecialChar, 'g'),
-	  safeSpecialCharRG = new RegExp(escapedSafeSpecialChar, 'g'),
-
-	  safeStartWithSpecialCharRG = new RegExp('(?:^|([^\\\\]))' + escapedSafeSpecialChar),
-
-	  indexOf = [].indexOf || function(v){
-	    for(var i=this.length;i--&&this[i]!==v;);
-	    return i;
-	  },
-	  $String = String  // there's no way to drop warnings in JSHint
-	                    // about new String ... well, I need that here!
-	                    // faked, and happy linter!
-	;
-
-	function generateReplacer(value, replacer, resolve) {
-	  var
-	    doNotIgnore = false,
-	    inspect = !!replacer,
-	    path = [],
-	    all  = [value],
-	    seen = [value],
-	    mapp = [resolve ? specialChar : '[Circular]'],
-	    last = value,
-	    lvl  = 1,
-	    i, fn
-	  ;
-	  if (inspect) {
-	    fn = typeof replacer === 'object' ?
-	      function (key, value) {
-	        return key !== '' && replacer.indexOf(key) < 0 ? void 0 : value;
-	      } :
-	      replacer;
-	  }
-	  return function(key, value) {
-	    // the replacer has rights to decide
-	    // if a new object should be returned
-	    // or if there's some key to drop
-	    // let's call it here rather than "too late"
-	    if (inspect) value = fn.call(this, key, value);
-
-	    // first pass should be ignored, since it's just the initial object
-	    if (doNotIgnore) {
-	      if (last !== this) {
-	        i = lvl - indexOf.call(all, this) - 1;
-	        lvl -= i;
-	        all.splice(lvl, all.length);
-	        path.splice(lvl - 1, path.length);
-	        last = this;
-	      }
-	      // console.log(lvl, key, path);
-	      if (typeof value === 'object' && value) {
-	    	// if object isn't referring to parent object, add to the
-	        // object path stack. Otherwise it is already there.
-	        if (indexOf.call(all, value) < 0) {
-	          all.push(last = value);
-	        }
-	        lvl = all.length;
-	        i = indexOf.call(seen, value);
-	        if (i < 0) {
-	          i = seen.push(value) - 1;
-	          if (resolve) {
-	            // key cannot contain specialChar but could be not a string
-	            path.push(('' + key).replace(specialCharRG, safeSpecialChar));
-	            mapp[i] = specialChar + path.join(specialChar);
-	          } else {
-	            mapp[i] = mapp[0];
-	          }
-	        } else {
-	          value = mapp[i];
-	        }
-	      } else {
-	        if (typeof value === 'string' && resolve) {
-	          // ensure no special char involved on deserialization
-	          // in this case only first char is important
-	          // no need to replace all value (better performance)
-	          value = value .replace(safeSpecialChar, escapedSafeSpecialChar)
-	                        .replace(specialChar, safeSpecialChar);
-	        }
-	      }
-	    } else {
-	      doNotIgnore = true;
-	    }
-	    return value;
-	  };
-	}
-
-	function retrieveFromPath(current, keys) {
-	  for(var i = 0, length = keys.length; i < length; current = current[
-	    // keys should be normalized back here
-	    keys[i++].replace(safeSpecialCharRG, specialChar)
-	  ]);
-	  return current;
-	}
-
-	function generateReviver(reviver) {
-	  return function(key, value) {
-	    var isString = typeof value === 'string';
-	    if (isString && value.charAt(0) === specialChar) {
-	      return new $String(value.slice(1));
-	    }
-	    if (key === '') value = regenerate(value, value, {});
-	    // again, only one needed, do not use the RegExp for this replacement
-	    // only keys need the RegExp
-	    if (isString) value = value .replace(safeStartWithSpecialCharRG, '$1' + specialChar)
-	                                .replace(escapedSafeSpecialChar, safeSpecialChar);
-	    return reviver ? reviver.call(this, key, value) : value;
-	  };
-	}
-
-	function regenerateArray(root, current, retrieve) {
-	  for (var i = 0, length = current.length; i < length; i++) {
-	    current[i] = regenerate(root, current[i], retrieve);
-	  }
-	  return current;
-	}
-
-	function regenerateObject(root, current, retrieve) {
-	  for (var key in current) {
-	    if (current.hasOwnProperty(key)) {
-	      current[key] = regenerate(root, current[key], retrieve);
-	    }
-	  }
-	  return current;
-	}
-
-	function regenerate(root, current, retrieve) {
-	  return current instanceof Array ?
-	    // fast Array reconstruction
-	    regenerateArray(root, current, retrieve) :
-	    (
-	      current instanceof $String ?
-	        (
-	          // root is an empty string
-	          current.length ?
-	            (
-	              retrieve.hasOwnProperty(current) ?
-	                retrieve[current] :
-	                retrieve[current] = retrieveFromPath(
-	                  root, current.split(specialChar)
-	                )
-	            ) :
-	            root
-	        ) :
-	        (
-	          current instanceof Object ?
-	            // dedicated Object parser
-	            regenerateObject(root, current, retrieve) :
-	            // value as it is
-	            current
-	        )
-	    )
-	  ;
-	}
-
-	var CircularJSON = {
-	  stringify: function stringify(value, replacer, space, doNotResolve) {
-	    return CircularJSON.parser.stringify(
-	      value,
-	      generateReplacer(value, replacer, !doNotResolve),
-	      space
-	    );
-	  },
-	  parse: function parse(text, reviver) {
-	    return CircularJSON.parser.parse(
-	      text,
-	      generateReviver(reviver)
-	    );
-	  },
-	  // A parser should be an API 1:1 compatible with JSON
-	  // it should expose stringify and parse methods.
-	  // The default parser is the native JSON.
-	  parser: JSON
-	};
-
-	var circularJson_node = CircularJSON;
-
 	/**
 	 * "Client" wraps "ws" or a browser-implemented "WebSocket" library
 	 * according to the environment providing JSON RPC 2.0 support on top.
@@ -18595,11 +18590,9 @@ var solanaWeb3 = (function (exports) {
 
 	var _eventemitter = eventemitter3.exports;
 
-	var _circularJson = _interopRequireDefault(circularJson_node);
-
 	function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = (0, _getPrototypeOf2["default"])(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = (0, _getPrototypeOf2["default"])(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return (0, _possibleConstructorReturn2["default"])(this, result); }; }
 
-	function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }
+	function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
 
 	var __rest = function (s, e) {
 	  var t = {};
@@ -18983,7 +18976,7 @@ var solanaWeb3 = (function (exports) {
 	        if (message instanceof ArrayBuffer) message = Buffer.from(message).toString();
 
 	        try {
-	          message = _circularJson["default"].parse(message);
+	          message = JSON.parse(message);
 	        } catch (error) {
 	          return;
 	        } // check if any listeners are attached and forward event
@@ -19054,6 +19047,8 @@ var solanaWeb3 = (function (exports) {
 	});
 	var Client_1 = index_browser.Client = void 0;
 
+	var _createClass2 = _interopRequireDefault(createClass.exports);
+
 	var _classCallCheck2 = _interopRequireDefault(classCallCheck.exports);
 
 	var _inherits2 = _interopRequireDefault(inherits$3.exports);
@@ -19068,7 +19063,7 @@ var solanaWeb3 = (function (exports) {
 
 	function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = (0, _getPrototypeOf2["default"])(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = (0, _getPrototypeOf2["default"])(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return (0, _possibleConstructorReturn2["default"])(this, result); }; }
 
-	function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }
+	function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
 
 	var Client = /*#__PURE__*/function (_CommonClient) {
 	  (0, _inherits2["default"])(Client, _CommonClient);
@@ -19098,7 +19093,7 @@ var solanaWeb3 = (function (exports) {
 	    }, generate_request_id);
 	  }
 
-	  return Client;
+	  return (0, _createClass2["default"])(Client);
 	}(_client["default"]);
 
 	Client_1 = index_browser.Client = Client;
@@ -20095,6 +20090,12 @@ var solanaWeb3 = (function (exports) {
 	 */
 
 	const BLOCKHASH_CACHE_TIMEOUT_MS = 30 * 1000;
+	/**
+	 * HACK.
+	 * Copied from rpc-websockets/dist/lib/client.
+	 * Otherwise, `yarn build` fails with:
+	 * https://gist.github.com/steveluscher/c057eca81d479ef705cdb53162f9971d
+	 */
 
 	/**
 	 * @internal
@@ -20963,14 +20964,9 @@ var solanaWeb3 = (function (exports) {
 	 * Filter for log subscriptions.
 	 */
 
-	function createSubscriptionWarningMessage(id, label) {
-	  return 'Ignored unsubscribe request because an active subscription ' + `with id \`${id}\` for '${label}' events could not be found.`;
-	}
 	/**
 	 * A connection to a fullnode JSON RPC endpoint
 	 */
-
-
 	class Connection {
 	  /** @internal */
 
@@ -20994,21 +20990,13 @@ var solanaWeb3 = (function (exports) {
 
 	  /** @internal */
 
-	  /** @internal */
-
-	  /** @internal */
-
-	  /** @internal */
-
-	  /** @internal */
-
-	  /** @internal */
-
-	  /** @internal */
-
-	  /** @internal */
-
-	  /** @internal */
+	  /** @internal
+	   * A number that we increment every time an active connection closes.
+	   * Used to determine whether the same socket connection that was open
+	   * when an async operation started is the same one that's active when
+	   * its continuation fires.
+	   *
+	   */
 
 	  /** @internal */
 
@@ -21024,7 +21012,19 @@ var solanaWeb3 = (function (exports) {
 
 	  /** @internal */
 
-	  /** @internal */
+	  /**
+	   * Special case.
+	   * After a signature is processed, RPCs automatically dispose of the
+	   * subscription on the server side. We need to track which of these
+	   * subscriptions have been disposed in such a way, so that we know
+	   * whether the client is dealing with a not-yet-processed signature
+	   * (in which case we must tear down the server subscription) or an
+	   * already-processed signature (in which case the client can simply
+	   * clear out the subscription locally without telling the server).
+	   *
+	   * NOTE: There is a proposal to eliminate this special case, here:
+	   * https://github.com/solana-labs/solana/issues/18892
+	   */
 
 	  /** @internal */
 
@@ -21046,6 +21046,7 @@ var solanaWeb3 = (function (exports) {
 	    this._rpcWebSocketConnected = false;
 	    this._rpcWebSocketHeartbeat = null;
 	    this._rpcWebSocketIdleTimeout = null;
+	    this._rpcWebSocketGeneration = 0;
 	    this._disableBlockhashCaching = false;
 	    this._pollingBlockhash = false;
 	    this._blockhashInfo = {
@@ -21054,20 +21055,11 @@ var solanaWeb3 = (function (exports) {
 	      transactionSignatures: [],
 	      simulatedSignatures: []
 	    };
-	    this._accountChangeSubscriptionCounter = 0;
-	    this._accountChangeSubscriptions = {};
-	    this._programAccountChangeSubscriptionCounter = 0;
-	    this._programAccountChangeSubscriptions = {};
-	    this._rootSubscriptionCounter = 0;
-	    this._rootSubscriptions = {};
-	    this._signatureSubscriptionCounter = 0;
-	    this._signatureSubscriptions = {};
-	    this._slotSubscriptionCounter = 0;
-	    this._slotSubscriptions = {};
-	    this._logsSubscriptionCounter = 0;
-	    this._logsSubscriptions = {};
-	    this._slotUpdateSubscriptionCounter = 0;
-	    this._slotUpdateSubscriptions = {};
+	    this._nextClientSubscriptionId = 0;
+	    this._subscriptionDisposeFunctionsByClientSubscriptionId = {};
+	    this._subscriptionCallbacksByServerSubscriptionId = {};
+	    this._subscriptionsByHash = {};
+	    this._subscriptionsAutoDisposedByRpc = new Set();
 	    let url = new URL(endpoint);
 	    const useHttps = url.protocol === 'https:';
 	    let wsEndpoint;
@@ -22835,6 +22827,8 @@ var solanaWeb3 = (function (exports) {
 
 
 	  _wsOnClose(code) {
+	    this._rpcWebSocketGeneration++;
+
 	    if (this._rpcWebSocketHeartbeat) {
 	      clearInterval(this._rpcWebSocketHeartbeat);
 	      this._rpcWebSocketHeartbeat = null;
@@ -22848,85 +22842,20 @@ var solanaWeb3 = (function (exports) {
 	    } // implicit close, prepare subscriptions for auto-reconnect
 
 
-	    this._resetSubscriptions();
-	  }
-	  /**
-	   * @internal
-	   */
-
-
-	  async _subscribe(sub, rpcMethod, rpcArgs) {
-	    if (sub.subscriptionId == null) {
-	      sub.subscriptionId = 'subscribing';
-
-	      try {
-	        const id = await this._rpcWebSocket.call(rpcMethod, rpcArgs);
-
-	        if (typeof id === 'number' && sub.subscriptionId === 'subscribing') {
-	          // eslint-disable-next-line require-atomic-updates
-	          sub.subscriptionId = id;
-	        }
-	      } catch (err) {
-	        if (sub.subscriptionId === 'subscribing') {
-	          // eslint-disable-next-line require-atomic-updates
-	          sub.subscriptionId = null;
-	        }
-
-	        if (err instanceof Error) {
-	          console.error(`${rpcMethod} error for argument`, rpcArgs, err.message);
-	        }
-	      }
-	    }
-	  }
-	  /**
-	   * @internal
-	   */
-
-
-	  async _unsubscribe(sub, rpcMethod) {
-	    const subscriptionId = sub.subscriptionId;
-
-	    if (subscriptionId != null && typeof subscriptionId != 'string') {
-	      const unsubscribeId = subscriptionId;
-
-	      try {
-	        await this._rpcWebSocket.call(rpcMethod, [unsubscribeId]);
-	      } catch (err) {
-	        if (err instanceof Error) {
-	          console.error(`${rpcMethod} error:`, err.message);
-	        }
-	      }
-	    }
-	  }
-	  /**
-	   * @internal
-	   */
-
-
-	  _resetSubscriptions() {
-	    Object.values(this._accountChangeSubscriptions).forEach(s => s.subscriptionId = null);
-	    Object.values(this._logsSubscriptions).forEach(s => s.subscriptionId = null);
-	    Object.values(this._programAccountChangeSubscriptions).forEach(s => s.subscriptionId = null);
-	    Object.values(this._rootSubscriptions).forEach(s => s.subscriptionId = null);
-	    Object.values(this._signatureSubscriptions).forEach(s => s.subscriptionId = null);
-	    Object.values(this._slotSubscriptions).forEach(s => s.subscriptionId = null);
-	    Object.values(this._slotUpdateSubscriptions).forEach(s => s.subscriptionId = null);
+	    this._subscriptionCallbacksByServerSubscriptionId = {};
+	    Object.entries(this._subscriptionsByHash).forEach(([hash, subscription]) => {
+	      this._subscriptionsByHash[hash] = { ...subscription,
+	        state: 'pending'
+	      };
+	    });
 	  }
 	  /**
 	   * @internal
 	   */
 
 
-	  _updateSubscriptions() {
-	    const accountKeys = Object.keys(this._accountChangeSubscriptions).map(Number);
-	    const programKeys = Object.keys(this._programAccountChangeSubscriptions).map(Number);
-	    const slotKeys = Object.keys(this._slotSubscriptions).map(Number);
-	    const slotUpdateKeys = Object.keys(this._slotUpdateSubscriptions).map(Number);
-	    const signatureKeys = Object.keys(this._signatureSubscriptions).map(Number);
-	    const rootKeys = Object.keys(this._rootSubscriptions).map(Number);
-	    const logsKeys = Object.keys(this._logsSubscriptions).map(Number);
-
-	    if (accountKeys.length === 0 && programKeys.length === 0 && slotKeys.length === 0 && slotUpdateKeys.length === 0 && signatureKeys.length === 0 && rootKeys.length === 0 && logsKeys.length === 0) {
+	  async _updateSubscriptions() {
+	    if (Object.keys(this._subscriptionsByHash).length === 0) {
 	      if (this._rpcWebSocketConnected) {
 	        this._rpcWebSocketConnected = false;
 	        this._rpcWebSocketIdleTimeout = setTimeout(() => {
@@ -22958,60 +22887,167 @@ var solanaWeb3 = (function (exports) {
 	      return;
 	    }
 
-	    for (let id of accountKeys) {
-	      const sub = this._accountChangeSubscriptions[id];
+	    const activeWebSocketGeneration = this._rpcWebSocketGeneration;
 
-	      this._subscribe(sub, 'accountSubscribe', this._buildArgs([sub.publicKey], sub.commitment, 'base64'));
-	    }
-
-	    for (let id of programKeys) {
-	      const sub = this._programAccountChangeSubscriptions[id];
+	    const isCurrentConnectionStillActive = () => {
+	      return activeWebSocketGeneration === this._rpcWebSocketGeneration;
+	    };
 
-	      this._subscribe(sub, 'programSubscribe', this._buildArgs([sub.programId], sub.commitment, 'base64', {
-	        filters: sub.filters
-	      }));
-	    }
+	    await Promise.all( // Don't be tempted to change this to `Object.entries`. We call
+	    // `_updateSubscriptions` recursively when processing the state,
+	    // so it's important that we look up the *current* version of
+	    // each subscription, every time we process a hash.
+	    Object.keys(this._subscriptionsByHash).map(async hash => {
+	      const subscription = this._subscriptionsByHash[hash];
 
-	    for (let id of slotKeys) {
-	      const sub = this._slotSubscriptions[id];
+	      if (subscription === undefined) {
+	        // This entry has since been deleted. Skip.
+	        return;
+	      }
 
-	      this._subscribe(sub, 'slotSubscribe', []);
-	    }
+	      switch (subscription.state) {
+	        case 'pending':
+	        case 'unsubscribed':
+	          if (subscription.callbacks.size === 0) {
+	            /**
+	             * You can end up here when:
+	             *
+	             * - a subscription has recently unsubscribed
+	             *   without having new callbacks added to it
+	             *   while the unsubscribe was in flight, or
+	             * - when a pending subscription has its
+	             *   listeners removed before a request was
+	             *   sent to the server.
+	             *
+	             * Being that nobody is interested in this
+	             * subscription any longer, delete it.
+	             */
+	            delete this._subscriptionsByHash[hash];
+
+	            if (subscription.state === 'unsubscribed') {
+	              delete this._subscriptionCallbacksByServerSubscriptionId[subscription.serverSubscriptionId];
+	            }
 
-	    for (let id of slotUpdateKeys) {
-	      const sub = this._slotUpdateSubscriptions[id];
+	            await this._updateSubscriptions();
+	            return;
+	          }
 
-	      this._subscribe(sub, 'slotsUpdatesSubscribe', []);
-	    }
+	          await (async () => {
+	            const {
+	              args,
+	              method
+	            } = subscription;
 
-	    for (let id of signatureKeys) {
-	      const sub = this._signatureSubscriptions[id];
-	      const args = [sub.signature];
-	      if (sub.options) args.push(sub.options);
+	            try {
+	              this._subscriptionsByHash[hash] = { ...subscription,
+	                state: 'subscribing'
+	              };
+	              const serverSubscriptionId = await this._rpcWebSocket.call(method, args);
+	              this._subscriptionsByHash[hash] = { ...subscription,
+	                serverSubscriptionId,
+	                state: 'subscribed'
+	              };
+	              this._subscriptionCallbacksByServerSubscriptionId[serverSubscriptionId] = subscription.callbacks;
+	              await this._updateSubscriptions();
+	            } catch (e) {
+	              if (e instanceof Error) {
+	                console.error(`${method} error for argument`, args, e.message);
+	              }
+
+	              if (!isCurrentConnectionStillActive()) {
+	                return;
+	              } // TODO: Maybe add an 'errored' state or a retry limit?
 
-	      this._subscribe(sub, 'signatureSubscribe', args);
-	    }
 
-	    for (let id of rootKeys) {
-	      const sub = this._rootSubscriptions[id];
+	              this._subscriptionsByHash[hash] = { ...subscription,
+	                state: 'pending'
+	              };
+	              await this._updateSubscriptions();
+	            }
+	          })();
+	          break;
 
-	      this._subscribe(sub, 'rootSubscribe', []);
-	    }
+	        case 'subscribed':
+	          if (subscription.callbacks.size === 0) {
+	            // By the time we successfully set up a subscription
+	            // with the server, the client stopped caring about it.
+	            // Tear it down now.
+	            await (async () => {
+	              const {
+	                serverSubscriptionId,
+	                unsubscribeMethod
+	              } = subscription;
+
+	              if (this._subscriptionsAutoDisposedByRpc.has(serverSubscriptionId)) {
+	                /**
+	                 * Special case.
+	                 * If we're dealing with a subscription that has been auto-
+	                 * disposed by the RPC, then we can skip the RPC call to
+	                 * tear down the subscription here.
+	                 *
+	                 * NOTE: There is a proposal to eliminate this special case, here:
+	                 * https://github.com/solana-labs/solana/issues/18892
+	                 */
+	                this._subscriptionsAutoDisposedByRpc.delete(serverSubscriptionId);
+	              } else {
+	                this._subscriptionsByHash[hash] = { ...subscription,
+	                  state: 'unsubscribing'
+	                };
+
+	                try {
+	                  await this._rpcWebSocket.call(unsubscribeMethod, [serverSubscriptionId]);
+	                } catch (e) {
+	                  if (e instanceof Error) {
+	                    console.error(`${unsubscribeMethod} error:`, e.message);
+	                  }
+
+	                  if (!isCurrentConnectionStillActive()) {
+	                    return;
+	                  } // TODO: Maybe add an 'errored' state or a retry limit?
+
+
+	                  this._subscriptionsByHash[hash] = { ...subscription,
+	                    state: 'subscribed'
+	                  };
+	                  await this._updateSubscriptions();
+	                  return;
+	                }
+	              }
 
-	    for (let id of logsKeys) {
-	      const sub = this._logsSubscriptions[id];
-	      let filter;
+	              this._subscriptionsByHash[hash] = { ...subscription,
+	                state: 'unsubscribed'
+	              };
+	              await this._updateSubscriptions();
+	            })();
+	          }
 
-	      if (typeof sub.filter === 'object') {
-	        filter = {
-	          mentions: [sub.filter.toString()]
-	        };
-	      } else {
-	        filter = sub.filter;
+	          break;
 	      }
+	    }));
+	  }
+	  /**
+	   * @internal
+	   */
+
 
-	      this._subscribe(sub, 'logsSubscribe', this._buildArgs([filter], sub.commitment));
+	  _handleServerNotification(serverSubscriptionId, callbackArgs) {
+	    const callbacks = this._subscriptionCallbacksByServerSubscriptionId[serverSubscriptionId];
+
+	    if (callbacks === undefined) {
+	      return;
 	    }
+
+	    callbacks.forEach(cb => {
+	      try {
+	        cb( // I failed to find a way to convince TypeScript that `cb` is of type
+	        // `TCallback` which is certainly compatible with `Parameters<TCallback>`.
+	        // See https://github.com/microsoft/TypeScript/issues/47615
+	        // @ts-ignore
+	        ...callbackArgs);
+	      } catch (e) {
+	        console.error(e);
+	      }
+	    });
 	  }
 	  /**
 	   * @internal
@@ -23019,14 +23055,71 @@ var solanaWeb3 = (function (exports) {
 
 
 	  _wsOnAccountNotification(notification) {
-	    const res = create(notification, AccountNotificationResult);
+	    const {
+	      result,
+	      subscription
+	    } = create(notification, AccountNotificationResult);
 
-	    for (const sub of Object.values(this._accountChangeSubscriptions)) {
-	      if (sub.subscriptionId === res.subscription) {
-	        sub.callback(res.result.value, res.result.context);
-	        return;
-	      }
+	    this._handleServerNotification(subscription, [result.value, result.context]);
+	  }
+	  /**
+	   * @internal
+	   */
+
+
+	  _makeSubscription(subscriptionConfig,
+	  /**
+	   * When preparing `args` for a call to `_makeSubscription`, be sure
+	   * to carefully apply a default `commitment` property, if necessary.
+	   *
+	   * - If the user supplied a `commitment` use that.
+	   * - Otherwise, if the `Connection::commitment` is set, use that.
+	   * - Otherwise, set it to the RPC server default: `finalized`.
+	   *
+	   * This is extremely important to ensure that these two fundamentally
+	   * identical subscriptions produce the same identifying hash:
+	   *
+	   * - A subscription made without specifying a commitment.
+	   * - A subscription made where the commitment specified is the same
+	   *   as the default applied to the subscription above.
+	   *
+	   * Example; these two subscriptions must produce the same hash:
+	   *
+	   * - An `accountSubscribe` subscription for `'PUBKEY'`
+	   * - An `accountSubscribe` subscription for `'PUBKEY'` with commitment
+	   *   `'finalized'`.
+	   *
+	   * See the 'making a subscription with defaulted params omitted' test
+	   * in `connection-subscriptions.ts` for more.
+	   */
+	  args) {
+	    const clientSubscriptionId = this._nextClientSubscriptionId++;
+	    const hash = fastStableStringify$1([subscriptionConfig.method, args], true
+	    /* isArrayProp */
+	    );
+	    const existingSubscription = this._subscriptionsByHash[hash];
+
+	    if (existingSubscription === undefined) {
+	      this._subscriptionsByHash[hash] = { ...subscriptionConfig,
+	        args,
+	        callbacks: new Set([subscriptionConfig.callback]),
+	        state: 'pending'
+	      };
+	    } else {
+	      existingSubscription.callbacks.add(subscriptionConfig.callback);
 	    }
+
+	    this._subscriptionDisposeFunctionsByClientSubscriptionId[clientSubscriptionId] = async () => {
+	      delete this._subscriptionDisposeFunctionsByClientSubscriptionId[clientSubscriptionId];
+	      const subscription = this._subscriptionsByHash[hash];
+	      assert$c(subscription !== undefined, `Could not find a \`Subscription\` when tearing down client subscription #${clientSubscriptionId}`);
+	      subscription.callbacks.delete(subscriptionConfig.callback);
+	      await this._updateSubscriptions();
+	    };
+
+	    this._updateSubscriptions();
+
+	    return clientSubscriptionId;
 	  }
 	  /**
 	   * Register a callback to be invoked whenever the specified account changes
@@ -23039,35 +23132,24 @@ var solanaWeb3 = (function (exports) {
 
 
 	  onAccountChange(publicKey, callback, commitment) {
-	    const id = ++this._accountChangeSubscriptionCounter;
-	    this._accountChangeSubscriptions[id] = {
-	      publicKey: publicKey.toBase58(),
-	      callback,
-	      commitment,
-	      subscriptionId: null
-	    };
+	    const args = this._buildArgs([publicKey.toBase58()], commitment || this._commitment || 'finalized', // Apply connection/server default.
+	    'base64');
 
-	    this._updateSubscriptions();
-
-	    return id;
+	    return this._makeSubscription({
+	      callback,
+	      method: 'accountSubscribe',
+	      unsubscribeMethod: 'accountUnsubscribe'
+	    }, args);
 	  }
 	  /**
 	   * Deregister an account notification callback
 	   *
-	   * @param id subscription id to deregister
+	   * @param id client subscription id to deregister
 	   */
 
 
-	  async removeAccountChangeListener(id) {
-	    if (this._accountChangeSubscriptions[id]) {
-	      const subInfo = this._accountChangeSubscriptions[id];
-	      delete this._accountChangeSubscriptions[id];
-	      await this._unsubscribe(subInfo, 'accountUnsubscribe');
-
-	      this._updateSubscriptions();
-	    } else {
-	      console.warn(createSubscriptionWarningMessage(id, 'account change'));
-	    }
+	  async removeAccountChangeListener(clientSubscriptionId) {
+	    await this._unsubscribeClientSubscription(clientSubscriptionId, 'account change');
 	  }
 	  /**
 	   * @internal
@@ -23075,21 +23157,15 @@ var solanaWeb3 = (function (exports) {
 
 
 	  _wsOnProgramAccountNotification(notification) {
-	    const res = create(notification, ProgramAccountNotificationResult);
+	    const {
+	      result,
+	      subscription
+	    } = create(notification, ProgramAccountNotificationResult);
 
-	    for (const sub of Object.values(this._programAccountChangeSubscriptions)) {
-	      if (sub.subscriptionId === res.subscription) {
-	        const {
-	          value,
-	          context
-	        } = res.result;
-	        sub.callback({
-	          accountId: value.pubkey,
-	          accountInfo: value.account
-	        }, context);
-	        return;
-	      }
-	    }
+	    this._handleServerNotification(subscription, [{
+	      accountId: result.value.pubkey,
+	      accountInfo: result.value.account
+	    }, result.context]);
 	  }
 	  /**
 	   * Register a callback to be invoked whenever accounts owned by the
@@ -23104,36 +23180,30 @@ var solanaWeb3 = (function (exports) {
 
 
 	  onProgramAccountChange(programId, callback, commitment, filters) {
-	    const id = ++this._programAccountChangeSubscriptionCounter;
-	    this._programAccountChangeSubscriptions[id] = {
-	      programId: programId.toBase58(),
-	      callback,
-	      commitment,
-	      subscriptionId: null,
-	      filters
-	    };
-
-	    this._updateSubscriptions();
+	    const args = this._buildArgs([programId.toBase58()], commitment || this._commitment || 'finalized', // Apply connection/server default.
+	    'base64'
+	    /* encoding */
+	    , filters ? {
+	      filters: filters
+	    } : undefined
+	    /* extra */
+	    );
 
-	    return id;
+	    return this._makeSubscription({
+	      callback,
+	      method: 'programSubscribe',
+	      unsubscribeMethod: 'programUnsubscribe'
+	    }, args);
 	  }
 	  /**
 	   * Deregister an account notification callback
 	   *
-	   * @param id subscription id to deregister
+	   * @param id client subscription id to deregister
 	   */
 
 
-	  async removeProgramAccountChangeListener(id) {
-	    if (this._programAccountChangeSubscriptions[id]) {
-	      const subInfo = this._programAccountChangeSubscriptions[id];
-	      delete this._programAccountChangeSubscriptions[id];
-	      await this._unsubscribe(subInfo, 'programUnsubscribe');
-
-	      this._updateSubscriptions();
-	    } else {
-	      console.warn(createSubscriptionWarningMessage(id, 'program account change'));
-	    }
+	  async removeProgramAccountChangeListener(clientSubscriptionId) {
+	    await this._unsubscribeClientSubscription(clientSubscriptionId, 'program account change');
 	  }
 	  /**
 	   * Registers a callback to be invoked whenever logs are emitted.
@@ -23141,35 +23211,26 @@ var solanaWeb3 = (function (exports) {
 
 
 	  onLogs(filter, callback, commitment) {
-	    const id = ++this._logsSubscriptionCounter;
-	    this._logsSubscriptions[id] = {
-	      filter,
-	      callback,
-	      commitment,
-	      subscriptionId: null
-	    };
-
-	    this._updateSubscriptions();
+	    const args = this._buildArgs([typeof filter === 'object' ? {
+	      mentions: [filter.toString()]
+	    } : filter], commitment || this._commitment || 'finalized' // Apply connection/server default.
+	    );
 
-	    return id;
+	    return this._makeSubscription({
+	      callback,
+	      method: 'logsSubscribe',
+	      unsubscribeMethod: 'logsUnsubscribe'
+	    }, args);
 	  }
 	  /**
 	   * Deregister a logs callback.
 	   *
-	   * @param id subscription id to deregister.
+	   * @param id client subscription id to deregister.
 	   */
 
 
-	  async removeOnLogsListener(id) {
-	    if (this._logsSubscriptions[id]) {
-	      const subInfo = this._logsSubscriptions[id];
-	      delete this._logsSubscriptions[id];
-	      await this._unsubscribe(subInfo, 'logsUnsubscribe');
-
-	      this._updateSubscriptions();
-	    } else {
-	      console.warn(createSubscriptionWarningMessage(id, 'logs'));
-	    }
+	  async removeOnLogsListener(clientSubscriptionId) {
+	    await this._unsubscribeClientSubscription(clientSubscriptionId, 'logs');
 	  }
 	  /**
 	   * @internal
@@ -23177,17 +23238,12 @@ var solanaWeb3 = (function (exports) {
 
 
 	  _wsOnLogsNotification(notification) {
-	    const res = create(notification, LogsNotificationResult);
-	    const keys = Object.keys(this._logsSubscriptions).map(Number);
-
-	    for (let id of keys) {
-	      const sub = this._logsSubscriptions[id];
+	    const {
+	      result,
+	      subscription
+	    } = create(notification, LogsNotificationResult);
 
-	      if (sub.subscriptionId === res.subscription) {
-	        sub.callback(res.result.value, res.result.context);
-	        return;
-	      }
-	    }
+	    this._handleServerNotification(subscription, [result.value, result.context]);
 	  }
 	  /**
 	   * @internal
@@ -23195,14 +23251,12 @@ var solanaWeb3 = (function (exports) {
 
 
 	  _wsOnSlotNotification(notification) {
-	    const res = create(notification, SlotNotificationResult);
+	    const {
+	      result,
+	      subscription
+	    } = create(notification, SlotNotificationResult);
 
-	    for (const sub of Object.values(this._slotSubscriptions)) {
-	      if (sub.subscriptionId === res.subscription) {
-	        sub.callback(res.result);
-	        return;
-	      }
-	    }
+	    this._handleServerNotification(subscription, [result]);
 	  }
 	  /**
 	   * Register a callback to be invoked upon slot changes
@@ -23213,33 +23267,23 @@ var solanaWeb3 = (function (exports) {
 
 
 	  onSlotChange(callback) {
-	    const id = ++this._slotSubscriptionCounter;
-	    this._slotSubscriptions[id] = {
+	    return this._makeSubscription({
 	      callback,
-	      subscriptionId: null
-	    };
-
-	    this._updateSubscriptions();
-
-	    return id;
+	      method: 'slotSubscribe',
+	      unsubscribeMethod: 'slotUnsubscribe'
+	    }, []
+	    /* args */
+	    );
 	  }
 	  /**
 	   * Deregister a slot notification callback
 	   *
-	   * @param id subscription id to deregister
+	   * @param id client subscription id to deregister
 	   */
 
 
-	  async removeSlotChangeListener(id) {
-	    if (this._slotSubscriptions[id]) {
-	      const subInfo = this._slotSubscriptions[id];
-	      delete this._slotSubscriptions[id];
-	      await this._unsubscribe(subInfo, 'slotUnsubscribe');
-
-	      this._updateSubscriptions();
-	    } else {
-	      console.warn(createSubscriptionWarningMessage(id, 'slot change'));
-	    }
+	  async removeSlotChangeListener(clientSubscriptionId) {
+	    await this._unsubscribeClientSubscription(clientSubscriptionId, 'slot change');
 	  }
 	  /**
 	   * @internal
@@ -23247,14 +23291,12 @@ var solanaWeb3 = (function (exports) {
 
 
 	  _wsOnSlotUpdatesNotification(notification) {
-	    const res = create(notification, SlotUpdateNotificationResult);
+	    const {
+	      result,
+	      subscription
+	    } = create(notification, SlotUpdateNotificationResult);
 
-	    for (const sub of Object.values(this._slotUpdateSubscriptions)) {
-	      if (sub.subscriptionId === res.subscription) {
-	        sub.callback(res.result);
-	        return;
-	      }
-	    }
+	    this._handleServerNotification(subscription, [result]);
 	  }
 	  /**
 	   * Register a callback to be invoked upon slot updates. {@link SlotUpdate}'s
@@ -23266,32 +23308,36 @@ var solanaWeb3 = (function (exports) {
 
 
 	  onSlotUpdate(callback) {
-	    const id = ++this._slotUpdateSubscriptionCounter;
-	    this._slotUpdateSubscriptions[id] = {
+	    return this._makeSubscription({
 	      callback,
-	      subscriptionId: null
-	    };
-
-	    this._updateSubscriptions();
-
-	    return id;
+	      method: 'slotsUpdatesSubscribe',
+	      unsubscribeMethod: 'slotsUpdatesUnsubscribe'
+	    }, []
+	    /* args */
+	    );
 	  }
 	  /**
 	   * Deregister a slot update notification callback
 	   *
-	   * @param id subscription id to deregister
+	   * @param id client subscription id to deregister
 	   */
 
 
-	  async removeSlotUpdateListener(id) {
-	    if (this._slotUpdateSubscriptions[id]) {
-	      const subInfo = this._slotUpdateSubscriptions[id];
-	      delete this._slotUpdateSubscriptions[id];
-	      await this._unsubscribe(subInfo, 'slotsUpdatesUnsubscribe');
+	  async removeSlotUpdateListener(clientSubscriptionId) {
+	    await this._unsubscribeClientSubscription(clientSubscriptionId, 'slot update');
+	  }
+	  /**
+	   * @internal
+	   */
 
-	      this._updateSubscriptions();
+
+	  async _unsubscribeClientSubscription(clientSubscriptionId, subscriptionName) {
+	    const dispose = this._subscriptionDisposeFunctionsByClientSubscriptionId[clientSubscriptionId];
+
+	    if (dispose) {
+	      await dispose();
 	    } else {
-	      console.warn(createSubscriptionWarningMessage(id, 'slot update'));
+	      console.warn('Ignored unsubscribe request because an active subscription with id ' + `\`${clientSubscriptionId}\` for '${subscriptionName}' events ` + 'could not be found.');
 	    }
 	  }
 
@@ -23338,30 +23384,34 @@ var solanaWeb3 = (function (exports) {
 
 
 	  _wsOnSignatureNotification(notification) {
-	    const res = create(notification, SignatureNotificationResult);
-
-	    for (const [id, sub] of Object.entries(this._signatureSubscriptions)) {
-	      if (sub.subscriptionId === res.subscription) {
-	        if (res.result.value === 'receivedSignature') {
-	          sub.callback({
-	            type: 'received'
-	          }, res.result.context);
-	        } else {
-	          // Signatures subscriptions are auto-removed by the RPC service so
-	          // no need to explicitly send an unsubscribe message
-	          delete this._signatureSubscriptions[Number(id)];
-
-	          this._updateSubscriptions();
-
-	          sub.callback({
-	            type: 'status',
-	            result: res.result.value
-	          }, res.result.context);
-	        }
-
-	        return;
-	      }
-	    }
+	    const {
+	      result,
+	      subscription
+	    } = create(notification, SignatureNotificationResult);
+
+	    if (result.value !== 'receivedSignature') {
+	      /**
+	       * Special case.
+	       * After a signature is processed, RPCs automatically dispose of the
+	       * subscription on the server side. We need to track which of these
+	       * subscriptions have been disposed in such a way, so that we know
+	       * whether the client is dealing with a not-yet-processed signature
+	       * (in which case we must tear down the server subscription) or an
+	       * already-processed signature (in which case the client can simply
+	       * clear out the subscription locally without telling the server).
+	       *
+	       * NOTE: There is a proposal to eliminate this special case, here:
+	       * https://github.com/solana-labs/solana/issues/18892
+	       */
+	      this._subscriptionsAutoDisposedByRpc.add(subscription);
+	    }
+
+	    this._handleServerNotification(subscription, result.value === 'receivedSignature' ? [{
+	      type: 'received'
+	    }, result.context] : [{
+	      type: 'status',
+	      result: result.value
+	    }, result.context]);
 	  }
 	  /**
 	   * Register a callback to be invoked upon signature updates
@@ -23374,23 +23424,26 @@ var solanaWeb3 = (function (exports) {
 
 
 	  onSignature(signature, callback, commitment) {
-	    const id = ++this._signatureSubscriptionCounter;
-	    this._signatureSubscriptions[id] = {
-	      signature,
+	    const args = this._buildArgs([signature], commitment || this._commitment || 'finalized' // Apply connection/server default.
+	    );
+
+	    const clientSubscriptionId = this._makeSubscription({
 	      callback: (notification, context) => {
 	        if (notification.type === 'status') {
-	          callback(notification.result, context);
+	          callback(notification.result, context); // Signatures subscriptions are auto-removed by the RPC service
+	          // so no need to explicitly send an unsubscribe message.
+
+	          try {
+	            this.removeSignatureListener(clientSubscriptionId); // eslint-disable-next-line no-empty
+	          } catch {// Already removed.
+	          }
 	        }
 	      },
-	      options: {
-	        commitment
-	      },
-	      subscriptionId: null
-	    };
+	      method: 'signatureSubscribe',
+	      unsubscribeMethod: 'signatureUnsubscribe'
+	    }, args);
 
-	    this._updateSubscriptions();
-
-	    return id;
+	    return clientSubscriptionId;
 	  }
 	  /**
 	   * Register a callback to be invoked when a transaction is
@@ -23405,35 +23458,43 @@ var solanaWeb3 = (function (exports) {
 
 
 	  onSignatureWithOptions(signature, callback, options) {
-	    const id = ++this._signatureSubscriptionCounter;
-	    this._signatureSubscriptions[id] = {
-	      signature,
-	      callback,
-	      options,
-	      subscriptionId: null
+	    const {
+	      commitment,
+	      ...extra
+	    } = { ...options,
+	      commitment: options && options.commitment || this._commitment || 'finalized' // Apply connection/server default.
+
 	    };
 
-	    this._updateSubscriptions();
+	    const args = this._buildArgs([signature], commitment, undefined
+	    /* encoding */
+	    , extra);
+
+	    const clientSubscriptionId = this._makeSubscription({
+	      callback: (notification, context) => {
+	        callback(notification, context); // Signatures subscriptions are auto-removed by the RPC service
+	        // so no need to explicitly send an unsubscribe message.
 
-	    return id;
+	        try {
+	          this.removeSignatureListener(clientSubscriptionId); // eslint-disable-next-line no-empty
+	        } catch {// Already removed.
+	        }
+	      },
+	      method: 'signatureSubscribe',
+	      unsubscribeMethod: 'signatureUnsubscribe'
+	    }, args);
+
+	    return clientSubscriptionId;
 	  }
 	  /**
 	   * Deregister a signature notification callback
 	   *
-	   * @param id subscription id to deregister
+	   * @param id client subscription id to deregister
 	   */
 
 
-	  async removeSignatureListener(id) {
-	    if (this._signatureSubscriptions[id]) {
-	      const subInfo = this._signatureSubscriptions[id];
-	      delete this._signatureSubscriptions[id];
-	      await this._unsubscribe(subInfo, 'signatureUnsubscribe');
-
-	      this._updateSubscriptions();
-	    } else {
-	      console.warn(createSubscriptionWarningMessage(id, 'signature result'));
-	    }
+	  async removeSignatureListener(clientSubscriptionId) {
+	    await this._unsubscribeClientSubscription(clientSubscriptionId, 'signature result');
 	  }
 	  /**
 	   * @internal
@@ -23441,14 +23502,12 @@ var solanaWeb3 = (function (exports) {
 
 
 	  _wsOnRootNotification(notification) {
-	    const res = create(notification, RootNotificationResult);
+	    const {
+	      result,
+	      subscription
+	    } = create(notification, RootNotificationResult);
 
-	    for (const sub of Object.values(this._rootSubscriptions)) {
-	      if (sub.subscriptionId === res.subscription) {
-	        sub.callback(res.result);
-	        return;
-	      }
-	    }
+	    this._handleServerNotification(subscription, [result]);
 	  }
 	  /**
 	   * Register a callback to be invoked upon root changes
@@ -23459,33 +23518,23 @@ var solanaWeb3 = (function (exports) {
 
 
 	  onRootChange(callback) {
-	    const id = ++this._rootSubscriptionCounter;
-	    this._rootSubscriptions[id] = {
+	    return this._makeSubscription({
 	      callback,
-	      subscriptionId: null
-	    };
-
-	    this._updateSubscriptions();
-
-	    return id;
+	      method: 'rootSubscribe',
+	      unsubscribeMethod: 'rootUnsubscribe'
+	    }, []
+	    /* args */
+	    );
 	  }
 	  /**
 	   * Deregister a root notification callback
 	   *
-	   * @param id subscription id to deregister
+	   * @param id client subscription id to deregister
 	   */
 
 
-	  async removeRootChangeListener(id) {
-	    if (this._rootSubscriptions[id]) {
-	      const subInfo = this._rootSubscriptions[id];
-	      delete this._rootSubscriptions[id];
-	      await this._unsubscribe(subInfo, 'rootUnsubscribe');
-
-	      this._updateSubscriptions();
-	    } else {
-	      console.warn(createSubscriptionWarningMessage(id, 'root change'));
-	    }
+	  async removeRootChangeListener(clientSubscriptionId) {
+	    await this._unsubscribeClientSubscription(clientSubscriptionId, 'root change');
 	  }
 
 	}
@@ -29975,6 +30024,9 @@ var solanaWeb3 = (function (exports) {
 	exports.BPF_LOADER_DEPRECATED_PROGRAM_ID = BPF_LOADER_DEPRECATED_PROGRAM_ID;
 	exports.BPF_LOADER_PROGRAM_ID = BPF_LOADER_PROGRAM_ID;
 	exports.BpfLoader = BpfLoader;
+	exports.COMPUTE_BUDGET_INSTRUCTION_LAYOUTS = COMPUTE_BUDGET_INSTRUCTION_LAYOUTS;
+	exports.ComputeBudgetInstruction = ComputeBudgetInstruction;
+	exports.ComputeBudgetProgram = ComputeBudgetProgram;
 	exports.Connection = Connection;
 	exports.Ed25519Program = Ed25519Program;
 	exports.Enum = Enum;
@@ -29988,7 +30040,6 @@ var solanaWeb3 = (function (exports) {
 	exports.Message = Message;
 	exports.NONCE_ACCOUNT_LENGTH = NONCE_ACCOUNT_LENGTH;
 	exports.NonceAccount = NonceAccount;
-	exports.PACKET_DATA_SIZE = PACKET_DATA_SIZE;
 	exports.PublicKey = PublicKey;
 	exports.SOLANA_SCHEMA = SOLANA_SCHEMA;
 	exports.STAKE_CONFIG_ID = STAKE_CONFIG_ID;