@solana/web3.js 1.41.1 → 1.41.4

package/lib/index.browser.esm.js

@@ -1,9 +1,10 @@
 import nacl from 'tweetnacl';
-import { Buffer } from 'buffer';
+import { Buffer as Buffer$1 } from 'buffer';
 import BN from 'bn.js';
 import bs58 from 'bs58';
 import { serialize, deserialize, deserializeUnchecked } from 'borsh';
 import * as BufferLayout from '@solana/buffer-layout';
+import { blob } from '@solana/buffer-layout';
 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';
@@ -11,12 +12,12 @@ import secp256k1 from 'secp256k1';
 import sha3 from 'js-sha3';
 
 const toBuffer = arr => {
-  if (Buffer.isBuffer(arr)) {
+  if (Buffer$1.isBuffer(arr)) {
     return arr;
   } else if (arr instanceof Uint8Array) {
-    return Buffer.from(arr.buffer, arr.byteOffset, arr.byteLength);
+    return Buffer$1.from(arr.buffer, arr.byteOffset, arr.byteLength);
   } else {
-    return Buffer.from(arr);
+    return Buffer$1.from(arr);
   }
 };
 
@@ -1737,7 +1738,7 @@ class Struct {
   }
 
   encode() {
-    return Buffer.from(serialize(SOLANA_SCHEMA, this));
+    return Buffer$1.from(serialize(SOLANA_SCHEMA, this));
   }
 
   static decode(data) {
@@ -1854,13 +1855,13 @@ class PublicKey extends Struct {
 
 
   toBuffer() {
-    const b = this._bn.toArrayLike(Buffer);
+    const b = this._bn.toArrayLike(Buffer$1);
 
     if (b.length === 32) {
       return b;
     }
 
-    const zeroPad = Buffer.alloc(32);
+    const zeroPad = Buffer$1.alloc(32);
     b.copy(zeroPad, 32 - b.length);
     return zeroPad;
   }
@@ -1882,9 +1883,9 @@ class PublicKey extends Struct {
 
 
   static async createWithSeed(fromPublicKey, seed, programId) {
-    const buffer = Buffer.concat([fromPublicKey.toBuffer(), Buffer.from(seed), programId.toBuffer()]);
+    const buffer = Buffer$1.concat([fromPublicKey.toBuffer(), Buffer$1.from(seed), programId.toBuffer()]);
     const hash = sha256(new Uint8Array(buffer)).slice(2);
-    return new PublicKey(Buffer.from(hash, 'hex'));
+    return new PublicKey(Buffer$1.from(hash, 'hex'));
   }
   /**
    * Derive a program address from seeds and a program ID.
@@ -1894,15 +1895,15 @@ class PublicKey extends Struct {
 
 
   static createProgramAddressSync(seeds, programId) {
-    let buffer = Buffer.alloc(0);
+    let buffer = Buffer$1.alloc(0);
     seeds.forEach(function (seed) {
       if (seed.length > MAX_SEED_LENGTH) {
         throw new TypeError(`Max seed length exceeded`);
       }
 
-      buffer = Buffer.concat([buffer, toBuffer(seed)]);
+      buffer = Buffer$1.concat([buffer, toBuffer(seed)]);
     });
-    buffer = Buffer.concat([buffer, programId.toBuffer(), Buffer.from('ProgramDerivedAddress')]);
+    buffer = Buffer$1.concat([buffer, programId.toBuffer(), Buffer$1.from('ProgramDerivedAddress')]);
     let hash = sha256(new Uint8Array(buffer)).slice(2);
     let publicKeyBytes = new BN(hash, 16).toArray(undefined, 32);
 
@@ -1938,7 +1939,7 @@ class PublicKey extends Struct {
 
     while (nonce != 0) {
       try {
-        const seedsWithNonce = seeds.concat(Buffer.from([nonce]));
+        const seedsWithNonce = seeds.concat(Buffer$1.from([nonce]));
         address = this.createProgramAddressSync(seedsWithNonce, programId);
       } catch (err) {
         if (err instanceof TypeError) {
@@ -2114,13 +2115,13 @@ const rustString = (property = 'string') => {
 
   rslShim.encode = (str, b, offset) => {
     const data = {
-      chars: Buffer.from(str, 'utf8')
+      chars: Buffer$1.from(str, 'utf8')
     };
     return _encode(data, b, offset);
   };
 
   rslShim.alloc = str => {
-    return BufferLayout.u32().span + BufferLayout.u32().span + Buffer.from(str, 'utf8').length;
+    return BufferLayout.u32().span + BufferLayout.u32().span + Buffer$1.from(str, 'utf8').length;
   };
 
   return rslShim;
@@ -2250,16 +2251,16 @@ class Message {
       encodeLength(dataCount, data.length);
       return {
         programIdIndex,
-        keyIndicesCount: Buffer.from(keyIndicesCount),
+        keyIndicesCount: Buffer$1.from(keyIndicesCount),
         keyIndices: accounts,
-        dataLength: Buffer.from(dataCount),
+        dataLength: Buffer$1.from(dataCount),
         data
       };
     });
     let instructionCount = [];
     encodeLength(instructionCount, instructions.length);
-    let instructionBuffer = Buffer.alloc(PACKET_DATA_SIZE);
-    Buffer.from(instructionCount).copy(instructionBuffer);
+    let instructionBuffer = Buffer$1.alloc(PACKET_DATA_SIZE);
+    Buffer$1.from(instructionCount).copy(instructionBuffer);
     let instructionBufferLength = instructionCount.length;
     instructions.forEach(instruction => {
       const instructionLayout = BufferLayout.struct([BufferLayout.u8('programIdIndex'), BufferLayout.blob(instruction.keyIndicesCount.length, 'keyIndicesCount'), BufferLayout.seq(BufferLayout.u8('keyIndex'), instruction.keyIndices.length, 'keyIndices'), BufferLayout.blob(instruction.dataLength.length, 'dataLength'), BufferLayout.seq(BufferLayout.u8('userdatum'), instruction.data.length, 'data')]);
@@ -2269,14 +2270,14 @@ class Message {
     instructionBuffer = instructionBuffer.slice(0, instructionBufferLength);
     const signDataLayout = BufferLayout.struct([BufferLayout.blob(1, 'numRequiredSignatures'), BufferLayout.blob(1, 'numReadonlySignedAccounts'), BufferLayout.blob(1, 'numReadonlyUnsignedAccounts'), BufferLayout.blob(keyCount.length, 'keyCount'), BufferLayout.seq(publicKey('key'), numKeys, 'keys'), publicKey('recentBlockhash')]);
     const transaction = {
-      numRequiredSignatures: Buffer.from([this.header.numRequiredSignatures]),
-      numReadonlySignedAccounts: Buffer.from([this.header.numReadonlySignedAccounts]),
-      numReadonlyUnsignedAccounts: Buffer.from([this.header.numReadonlyUnsignedAccounts]),
-      keyCount: Buffer.from(keyCount),
+      numRequiredSignatures: Buffer$1.from([this.header.numRequiredSignatures]),
+      numReadonlySignedAccounts: Buffer$1.from([this.header.numReadonlySignedAccounts]),
+      numReadonlyUnsignedAccounts: Buffer$1.from([this.header.numReadonlyUnsignedAccounts]),
+      keyCount: Buffer$1.from(keyCount),
       keys: this.accountKeys.map(key => toBuffer(key.toBytes())),
       recentBlockhash: bs58.decode(this.recentBlockhash)
     };
-    let signData = Buffer.alloc(2048);
+    let signData = Buffer$1.alloc(2048);
     const length = signDataLayout.encode(transaction, signData);
     instructionBuffer.copy(signData, length);
     return signData.slice(0, length + instructionBuffer.length);
@@ -2298,7 +2299,7 @@ class Message {
     for (let i = 0; i < accountCount; i++) {
       const account = byteArray.slice(0, PUBKEY_LENGTH);
       byteArray = byteArray.slice(PUBKEY_LENGTH);
-      accountKeys.push(bs58.encode(Buffer.from(account)));
+      accountKeys.push(bs58.encode(Buffer$1.from(account)));
     }
 
     const recentBlockhash = byteArray.slice(0, PUBKEY_LENGTH);
@@ -2313,7 +2314,7 @@ class Message {
       byteArray = byteArray.slice(accountCount);
       const dataLength = decodeLength(byteArray);
       const dataSlice = byteArray.slice(0, dataLength);
-      const data = bs58.encode(Buffer.from(dataSlice));
+      const data = bs58.encode(Buffer$1.from(dataSlice));
       byteArray = byteArray.slice(dataLength);
       instructions.push({
         programIdIndex,
@@ -2328,7 +2329,7 @@ class Message {
         numReadonlySignedAccounts,
         numReadonlyUnsignedAccounts
       },
-      recentBlockhash: bs58.encode(Buffer.from(recentBlockhash)),
+      recentBlockhash: bs58.encode(Buffer$1.from(recentBlockhash)),
       accountKeys,
       instructions
     };
@@ -2346,7 +2347,7 @@ function assert (condition, message) {
 /**
  * Default (empty) signature
  */
-const DEFAULT_SIGNATURE = Buffer.alloc(SIGNATURE_LENGTH_IN_BYTES).fill(0);
+const DEFAULT_SIGNATURE = Buffer$1.alloc(SIGNATURE_LENGTH_IN_BYTES).fill(0);
 /**
  * Account metadata used to define instructions
  */
@@ -2370,7 +2371,7 @@ class TransactionInstruction {
   constructor(opts) {
     this.keys = void 0;
     this.programId = void 0;
-    this.data = Buffer.alloc(0);
+    this.data = Buffer$1.alloc(0);
     this.programId = opts.programId;
     this.keys = opts.keys;
 
@@ -2853,7 +2854,7 @@ class Transaction {
       throw new Error(`unknown signer: ${pubkey.toString()}`);
     }
 
-    this.signatures[index].signature = Buffer.from(signature);
+    this.signatures[index].signature = Buffer$1.from(signature);
   }
   /**
    * Verify signatures of a complete, signed Transaction
@@ -2919,15 +2920,15 @@ class Transaction {
     const signatureCount = [];
     encodeLength(signatureCount, signatures.length);
     const transactionLength = signatureCount.length + signatures.length * 64 + signData.length;
-    const wireTransaction = Buffer.alloc(transactionLength);
+    const wireTransaction = Buffer$1.alloc(transactionLength);
     assert(signatures.length < 256);
-    Buffer.from(signatureCount).copy(wireTransaction, 0);
+    Buffer$1.from(signatureCount).copy(wireTransaction, 0);
     signatures.forEach(({
       signature
     }, index) => {
       if (signature !== null) {
         assert(signature.length === 64, `signature has invalid length`);
-        Buffer.from(signature).copy(wireTransaction, signatureCount.length + index * 64);
+        Buffer$1.from(signature).copy(wireTransaction, signatureCount.length + index * 64);
       }
     });
     signData.copy(wireTransaction, signatureCount.length + signatures.length * 64);
@@ -2978,7 +2979,7 @@ class Transaction {
     for (let i = 0; i < signatureCount; i++) {
       const signature = byteArray.slice(0, SIGNATURE_LENGTH_IN_BYTES);
       byteArray = byteArray.slice(SIGNATURE_LENGTH_IN_BYTES);
-      signatures.push(bs58.encode(Buffer.from(signature)));
+      signatures.push(bs58.encode(Buffer$1.from(signature)));
     }
 
     return Transaction.populate(Message.from(byteArray), signatures);
@@ -3067,13 +3068,99 @@ function sleep(ms) {
   return new Promise(resolve => setTimeout(resolve, ms));
 }
 
+const encodeDecode = (layout) => {
+    const decode = layout.decode.bind(layout);
+    const encode = layout.encode.bind(layout);
+    return { decode, encode };
+};
+
+var browser = {};
+
+Object.defineProperty(browser, "__esModule", { value: true });
+/**
+ * Convert a little-endian buffer into a BigInt.
+ * @param buf The little-endian buffer to convert
+ * @returns A BigInt with the little-endian representation of buf.
+ */
+function toBigIntLE(buf) {
+    {
+        const reversed = Buffer.from(buf);
+        reversed.reverse();
+        const hex = reversed.toString('hex');
+        if (hex.length === 0) {
+            return BigInt(0);
+        }
+        return BigInt(`0x${hex}`);
+    }
+}
+var toBigIntLE_1 = browser.toBigIntLE = toBigIntLE;
+/**
+ * Convert a big-endian buffer into a BigInt
+ * @param buf The big-endian buffer to convert.
+ * @returns A BigInt with the big-endian representation of buf.
+ */
+function toBigIntBE(buf) {
+    {
+        const hex = buf.toString('hex');
+        if (hex.length === 0) {
+            return BigInt(0);
+        }
+        return BigInt(`0x${hex}`);
+    }
+}
+browser.toBigIntBE = toBigIntBE;
+/**
+ * Convert a BigInt to a little-endian buffer.
+ * @param num   The BigInt to convert.
+ * @param width The number of bytes that the resulting buffer should be.
+ * @returns A little-endian buffer representation of num.
+ */
+function toBufferLE(num, width) {
+    {
+        const hex = num.toString(16);
+        const buffer = Buffer.from(hex.padStart(width * 2, '0').slice(0, width * 2), 'hex');
+        buffer.reverse();
+        return buffer;
+    }
+}
+var toBufferLE_1 = browser.toBufferLE = toBufferLE;
+/**
+ * Convert a BigInt to a big-endian buffer.
+ * @param num   The BigInt to convert.
+ * @param width The number of bytes that the resulting buffer should be.
+ * @returns A big-endian buffer representation of num.
+ */
+function toBufferBE(num, width) {
+    {
+        const hex = num.toString(16);
+        return Buffer.from(hex.padStart(width * 2, '0').slice(0, width * 2), 'hex');
+    }
+}
+browser.toBufferBE = toBufferBE;
+
+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_1(Buffer.from(src));
+    };
+    bigIntLayout.encode = (bigInt, buffer, offset) => {
+        const src = toBufferLE_1(bigInt, length);
+        return encode(src, buffer, offset);
+    };
+    return bigIntLayout;
+};
+const u64 = bigInt(8);
+
 /**
  * Populate a buffer of instruction data using an InstructionType
  * @internal
  */
 function encodeData(type, fields) {
   const allocLength = type.layout.span >= 0 ? type.layout.span : getAlloc(type, fields);
-  const data = Buffer.alloc(allocLength);
+  const data = Buffer$1.alloc(allocLength);
   const layoutFields = Object.assign({
     instruction: type.index
   }, fields);
@@ -3456,7 +3543,7 @@ const SYSTEM_INSTRUCTION_LAYOUTS = Object.freeze({
   },
   Transfer: {
     index: 2,
-    layout: BufferLayout.struct([BufferLayout.u32('instruction'), BufferLayout.ns64('lamports')])
+    layout: BufferLayout.struct([BufferLayout.u32('instruction'), u64('lamports')])
   },
   CreateWithSeed: {
     index: 3,
@@ -3492,7 +3579,7 @@ const SYSTEM_INSTRUCTION_LAYOUTS = Object.freeze({
   },
   TransferWithSeed: {
     index: 11,
-    layout: BufferLayout.struct([BufferLayout.u32('instruction'), BufferLayout.ns64('lamports'), rustString('seed'), publicKey('programId')])
+    layout: BufferLayout.struct([BufferLayout.u32('instruction'), u64('lamports'), rustString('seed'), publicKey('programId')])
   }
 });
 /**
@@ -3545,7 +3632,7 @@ class SystemProgram {
     if ('basePubkey' in params) {
       const type = SYSTEM_INSTRUCTION_LAYOUTS.TransferWithSeed;
       data = encodeData(type, {
-        lamports: params.lamports,
+        lamports: BigInt(params.lamports),
         seed: params.seed,
         programId: toBuffer(params.programId.toBuffer())
       });
@@ -3565,7 +3652,7 @@ class SystemProgram {
     } else {
       const type = SYSTEM_INSTRUCTION_LAYOUTS.Transfer;
       data = encodeData(type, {
-        lamports: params.lamports
+        lamports: BigInt(params.lamports)
       });
       keys = [{
         pubkey: params.fromPubkey,
@@ -3973,7 +4060,7 @@ class Loader {
 
     while (array.length > 0) {
       const bytes = array.slice(0, chunkSize);
-      const data = Buffer.alloc(chunkSize + 16);
+      const data = Buffer$1.alloc(chunkSize + 16);
       dataLayout.encode({
         instruction: 0,
         // Load instruction
@@ -4008,7 +4095,7 @@ class Loader {
 
     {
       const dataLayout = BufferLayout.struct([BufferLayout.u32('instruction')]);
-      const data = Buffer.alloc(dataLayout.span);
+      const data = Buffer$1.alloc(dataLayout.span);
       dataLayout.encode({
         instruction: 1 // Finalize instruction
 
@@ -4761,6 +4848,82 @@ module.exports = 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(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(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(val[i], true) + ',';
+					}
+					if (max > -1) {
+						str += stringify(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(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(val, false);
+	if (returnVal !== undefined) {
+		return ''+ returnVal;
+	}
+};
+
+var fastStableStringify$1 = fastStableStringify;
+
 const MINIMUM_SLOT_PER_EPOCH = 32; // Returns the number of trailing zeros in the binary representation of self.
 
 function trailingZeros(n) {
@@ -4920,13 +5083,19 @@ function makeWebsocketUrl(endpoint) {
 
 const PublicKeyFromString = coerce(instance(PublicKey), string(), value => new PublicKey(value));
 const RawAccountDataResult = tuple([string(), literal('base64')]);
-const BufferFromRawAccountData = coerce(instance(Buffer), RawAccountDataResult, value => Buffer.from(value[0], 'base64'));
+const BufferFromRawAccountData = coerce(instance(Buffer$1), RawAccountDataResult, value => Buffer$1.from(value[0], 'base64'));
 /**
  * Attempt to use a recent blockhash for up to 30 seconds
  * @internal
  */
 
 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
@@ -5337,7 +5506,7 @@ const KeyedAccountInfoResult = type({
   pubkey: PublicKeyFromString,
   account: AccountInfoResult
 });
-const ParsedOrRawAccountData = coerce(union([instance(Buffer), ParsedAccountDataResult]), union([RawAccountDataResult, ParsedAccountDataResult]), value => {
+const ParsedOrRawAccountData = coerce(union([instance(Buffer$1), ParsedAccountDataResult]), union([RawAccountDataResult, ParsedAccountDataResult]), value => {
   if (Array.isArray(value)) {
     return create(value, BufferFromRawAccountData);
   } else {
@@ -5795,14 +5964,9 @@ const LogsNotificationResult = type({
  * 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 */
 
@@ -5826,21 +5990,13 @@ class Connection {
 
   /** @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 */
 
@@ -5856,7 +6012,19 @@ class Connection {
 
   /** @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 */
 
@@ -5878,6 +6046,7 @@ class Connection {
     this._rpcWebSocketConnected = false;
     this._rpcWebSocketHeartbeat = null;
     this._rpcWebSocketIdleTimeout = null;
+    this._rpcWebSocketGeneration = 0;
     this._disableBlockhashCaching = false;
     this._pollingBlockhash = false;
     this._blockhashInfo = {
@@ -5886,20 +6055,11 @@ class Connection {
       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;
@@ -7667,6 +7827,8 @@ class Connection {
 
 
   _wsOnClose(code) {
+    this._rpcWebSocketGeneration++;
+
     if (this._rpcWebSocketHeartbeat) {
       clearInterval(this._rpcWebSocketHeartbeat);
       this._rpcWebSocketHeartbeat = null;
@@ -7680,85 +7842,20 @@ class Connection {
     } // 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(() => {
@@ -7790,60 +7887,167 @@ class Connection {
       return;
     }
 
-    for (let id of accountKeys) {
-      const sub = this._accountChangeSubscriptions[id];
-
-      this._subscribe(sub, 'accountSubscribe', this._buildArgs([sub.publicKey], sub.commitment, 'base64'));
-    }
+    const activeWebSocketGeneration = this._rpcWebSocketGeneration;
 
-    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
@@ -7851,14 +8055,71 @@ class Connection {
 
 
   _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(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
@@ -7871,35 +8132,24 @@ class Connection {
 
 
   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
@@ -7907,21 +8157,15 @@ class Connection {
 
 
   _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
@@ -7936,36 +8180,30 @@ class Connection {
 
 
   onProgramAccountChange(programId, callback, commitment, filters) {
-    const id = ++this._programAccountChangeSubscriptionCounter;
-    this._programAccountChangeSubscriptions[id] = {
-      programId: programId.toBase58(),
+    const args = this._buildArgs([programId.toBase58()], commitment || this._commitment || 'finalized', // Apply connection/server default.
+    'base64'
+    /* encoding */
+    , filters ? {
+      filters: filters
+    } : undefined
+    /* extra */
+    );
+
+    return this._makeSubscription({
       callback,
-      commitment,
-      subscriptionId: null,
-      filters
-    };
-
-    this._updateSubscriptions();
-
-    return id;
+      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.
@@ -7973,35 +8211,26 @@ class Connection {
 
 
   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
@@ -8009,17 +8238,12 @@ class Connection {
 
 
   _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
@@ -8027,14 +8251,12 @@ class Connection {
 
 
   _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
@@ -8045,33 +8267,23 @@ class Connection {
 
 
   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
@@ -8079,14 +8291,12 @@ class Connection {
 
 
   _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
@@ -8098,32 +8308,36 @@ class Connection {
 
 
   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(clientSubscriptionId) {
+    await this._unsubscribeClientSubscription(clientSubscriptionId, 'slot update');
+  }
+  /**
+   * @internal
    */
 
 
-  async removeSlotUpdateListener(id) {
-    if (this._slotUpdateSubscriptions[id]) {
-      const subInfo = this._slotUpdateSubscriptions[id];
-      delete this._slotUpdateSubscriptions[id];
-      await this._unsubscribe(subInfo, 'slotsUpdatesUnsubscribe');
+  async _unsubscribeClientSubscription(clientSubscriptionId, subscriptionName) {
+    const dispose = this._subscriptionDisposeFunctionsByClientSubscriptionId[clientSubscriptionId];
 
-      this._updateSubscriptions();
+    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.');
     }
   }
 
@@ -8170,30 +8384,34 @@ class Connection {
 
 
   _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
@@ -8206,23 +8424,26 @@ class Connection {
 
 
   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
-    };
-
-    this._updateSubscriptions();
+      method: 'signatureSubscribe',
+      unsubscribeMethod: 'signatureUnsubscribe'
+    }, args);
 
-    return id;
+    return clientSubscriptionId;
   }
   /**
    * Register a callback to be invoked when a transaction is
@@ -8237,35 +8458,43 @@ class Connection {
 
 
   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.
+
+        try {
+          this.removeSignatureListener(clientSubscriptionId); // eslint-disable-next-line no-empty
+        } catch {// Already removed.
+        }
+      },
+      method: 'signatureSubscribe',
+      unsubscribeMethod: 'signatureUnsubscribe'
+    }, args);
 
-    return id;
+    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
@@ -8273,14 +8502,12 @@ class Connection {
 
 
   _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
@@ -8291,33 +8518,23 @@ class Connection {
 
 
   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');
   }
 
 }
@@ -8447,7 +8664,7 @@ class Ed25519Program {
     const signatureOffset = publicKeyOffset + publicKey.length;
     const messageDataOffset = signatureOffset + signature.length;
     const numSignatures = 1;
-    const instructionData = Buffer.alloc(messageDataOffset + message.length);
+    const instructionData = Buffer$1.alloc(messageDataOffset + message.length);
     const index = instructionIndex == null ? 0xffff // An index of `u16::MAX` makes it default to the current instruction.
     : instructionIndex;
     ED25519_INSTRUCTION_LAYOUT.encode({
@@ -9318,7 +9535,7 @@ class Secp256k1Program {
     assert(publicKey.length === PUBLIC_KEY_BYTES, `Public key must be ${PUBLIC_KEY_BYTES} bytes but received ${publicKey.length} bytes`);
 
     try {
-      return Buffer.from(sha3.keccak_256.update(toBuffer(publicKey)).digest()).slice(-ETHEREUM_ADDRESS_BYTES);
+      return Buffer$1.from(sha3.keccak_256.update(toBuffer(publicKey)).digest()).slice(-ETHEREUM_ADDRESS_BYTES);
     } catch (error) {
       throw new Error(`Error constructing Ethereum address: ${error}`);
     }
@@ -9363,9 +9580,9 @@ class Secp256k1Program {
 
     if (typeof rawAddress === 'string') {
       if (rawAddress.startsWith('0x')) {
-        ethAddress = Buffer.from(rawAddress.substr(2), 'hex');
+        ethAddress = Buffer$1.from(rawAddress.substr(2), 'hex');
       } else {
-        ethAddress = Buffer.from(rawAddress, 'hex');
+        ethAddress = Buffer$1.from(rawAddress, 'hex');
       }
     } else {
       ethAddress = rawAddress;
@@ -9377,7 +9594,7 @@ class Secp256k1Program {
     const signatureOffset = dataStart + ethAddress.length;
     const messageDataOffset = signatureOffset + signature.length + 1;
     const numSignatures = 1;
-    const instructionData = Buffer.alloc(SECP256K1_INSTRUCTION_LAYOUT.span + message.length);
+    const instructionData = Buffer$1.alloc(SECP256K1_INSTRUCTION_LAYOUT.span + message.length);
     SECP256K1_INSTRUCTION_LAYOUT.encode({
       numSignatures,
       signatureOffset,
@@ -9416,7 +9633,7 @@ class Secp256k1Program {
       const privateKey = toBuffer(pkey);
       const publicKey = publicKeyCreate(privateKey, false).slice(1); // throw away leading byte
 
-      const messageHash = Buffer.from(sha3.keccak_256.update(toBuffer(message)).digest());
+      const messageHash = Buffer$1.from(sha3.keccak_256.update(toBuffer(message)).digest());
       const {
         signature,
         recid: recoveryId
@@ -9501,7 +9718,7 @@ class ValidatorInfo {
 
     if (configKeys[0].publicKey.equals(VALIDATOR_INFO_KEY)) {
       if (configKeys[1].isSigner) {
-        const rawInfo = rustString().decode(Buffer.from(byteArray));
+        const rawInfo = rustString().decode(Buffer$1.from(byteArray));
         const info = JSON.parse(rawInfo);
         assert$7(info, InfoString);
         return new ValidatorInfo(configKeys[1].publicKey, info);
@@ -9997,5 +10214,5 @@ function clusterApiUrl(cluster, tls) {
 
 const LAMPORTS_PER_SOL = 1000000000;
 
-export { Account, Authorized, BLOCKHASH_CACHE_TIMEOUT_MS, BPF_LOADER_DEPRECATED_PROGRAM_ID, BPF_LOADER_PROGRAM_ID, BpfLoader, COMPUTE_BUDGET_INSTRUCTION_LAYOUTS, ComputeBudgetInstruction, ComputeBudgetProgram, Connection, Ed25519Program, Enum, EpochSchedule, FeeCalculatorLayout, Keypair, LAMPORTS_PER_SOL, Loader, Lockup, MAX_SEED_LENGTH, Message, NONCE_ACCOUNT_LENGTH, NonceAccount, PublicKey, SOLANA_SCHEMA, STAKE_CONFIG_ID, STAKE_INSTRUCTION_LAYOUTS, SYSTEM_INSTRUCTION_LAYOUTS, SYSVAR_CLOCK_PUBKEY, SYSVAR_EPOCH_SCHEDULE_PUBKEY, SYSVAR_INSTRUCTIONS_PUBKEY, SYSVAR_RECENT_BLOCKHASHES_PUBKEY, SYSVAR_RENT_PUBKEY, SYSVAR_REWARDS_PUBKEY, SYSVAR_SLOT_HASHES_PUBKEY, SYSVAR_SLOT_HISTORY_PUBKEY, SYSVAR_STAKE_HISTORY_PUBKEY, Secp256k1Program, SendTransactionError, StakeAuthorizationLayout, StakeInstruction, StakeProgram, Struct, SystemInstruction, SystemProgram, Transaction, TransactionInstruction, VALIDATOR_INFO_KEY, VOTE_PROGRAM_ID, ValidatorInfo, VoteAccount, VoteAuthorizationLayout, VoteInit, VoteInstruction, VoteProgram, clusterApiUrl, sendAndConfirmRawTransaction, sendAndConfirmTransaction };
+export { Account, Authorized, BLOCKHASH_CACHE_TIMEOUT_MS, BPF_LOADER_DEPRECATED_PROGRAM_ID, BPF_LOADER_PROGRAM_ID, BpfLoader, COMPUTE_BUDGET_INSTRUCTION_LAYOUTS, ComputeBudgetInstruction, ComputeBudgetProgram, Connection, Ed25519Program, Enum, EpochSchedule, FeeCalculatorLayout, Keypair, LAMPORTS_PER_SOL, Loader, Lockup, MAX_SEED_LENGTH, Message, NONCE_ACCOUNT_LENGTH, NonceAccount, PACKET_DATA_SIZE, PublicKey, SIGNATURE_LENGTH_IN_BYTES, SOLANA_SCHEMA, STAKE_CONFIG_ID, STAKE_INSTRUCTION_LAYOUTS, SYSTEM_INSTRUCTION_LAYOUTS, SYSVAR_CLOCK_PUBKEY, SYSVAR_EPOCH_SCHEDULE_PUBKEY, SYSVAR_INSTRUCTIONS_PUBKEY, SYSVAR_RECENT_BLOCKHASHES_PUBKEY, SYSVAR_RENT_PUBKEY, SYSVAR_REWARDS_PUBKEY, SYSVAR_SLOT_HASHES_PUBKEY, SYSVAR_SLOT_HISTORY_PUBKEY, SYSVAR_STAKE_HISTORY_PUBKEY, Secp256k1Program, SendTransactionError, StakeAuthorizationLayout, StakeInstruction, StakeProgram, Struct, SystemInstruction, SystemProgram, Transaction, TransactionInstruction, VALIDATOR_INFO_KEY, VOTE_PROGRAM_ID, ValidatorInfo, VoteAccount, VoteAuthorizationLayout, VoteInit, VoteInstruction, VoteProgram, clusterApiUrl, sendAndConfirmRawTransaction, sendAndConfirmTransaction };
 //# sourceMappingURL=index.browser.esm.js.map