@solana/web3.js 1.41.0 → 1.41.3

package/lib/index.browser.cjs.js

@@ -2108,6 +2108,16 @@ class Account {
 
 const BPF_LOADER_DEPRECATED_PROGRAM_ID = new PublicKey('BPFLoader1111111111111111111111111111111111');
 
+/**
+ * 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
  */
@@ -2367,20 +2377,8 @@ function assert (condition, message) {
 
 /**
  * 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
  */
@@ -3010,8 +3008,8 @@ class Transaction {
     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__default["default"].encode(buffer.Buffer.from(signature)));
     }
 
@@ -3900,11 +3898,11 @@ class SystemProgram {
 }
 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
@@ -4795,6 +4793,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) {
@@ -4961,6 +5035,12 @@ const BufferFromRawAccountData = superstruct.coerce(superstruct.instance(buffer.
  */
 
 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
@@ -5829,14 +5909,9 @@ const LogsNotificationResult = superstruct.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 */
 
@@ -5860,21 +5935,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 */
 
@@ -5890,7 +5957,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 */
 
@@ -5912,6 +5991,7 @@ class Connection {
     this._rpcWebSocketConnected = false;
     this._rpcWebSocketHeartbeat = null;
     this._rpcWebSocketIdleTimeout = null;
+    this._rpcWebSocketGeneration = 0;
     this._disableBlockhashCaching = false;
     this._pollingBlockhash = false;
     this._blockhashInfo = {
@@ -5920,20 +6000,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;
@@ -7701,6 +7772,8 @@ class Connection {
 
 
   _wsOnClose(code) {
+    this._rpcWebSocketGeneration++;
+
     if (this._rpcWebSocketHeartbeat) {
       clearInterval(this._rpcWebSocketHeartbeat);
       this._rpcWebSocketHeartbeat = null;
@@ -7714,85 +7787,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(() => {
@@ -7824,60 +7832,167 @@ class Connection {
       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
@@ -7885,14 +8000,71 @@ class Connection {
 
 
   _wsOnAccountNotification(notification) {
-    const res = superstruct.create(notification, AccountNotificationResult);
+    const {
+      result,
+      subscription
+    } = superstruct.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
@@ -7905,35 +8077,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
@@ -7941,21 +8102,15 @@ class Connection {
 
 
   _wsOnProgramAccountNotification(notification) {
-    const res = superstruct.create(notification, ProgramAccountNotificationResult);
+    const {
+      result,
+      subscription
+    } = superstruct.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
@@ -7970,36 +8125,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.
@@ -8007,35 +8156,26 @@ class Connection {
 
 
   onLogs(filter, callback, commitment) {
-    const id = ++this._logsSubscriptionCounter;
-    this._logsSubscriptions[id] = {
-      filter,
-      callback,
-      commitment,
-      subscriptionId: null
-    };
+    const args = this._buildArgs([typeof filter === 'object' ? {
+      mentions: [filter.toString()]
+    } : filter], commitment || this._commitment || 'finalized' // Apply connection/server default.
+    );
 
-    this._updateSubscriptions();
-
-    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
@@ -8043,17 +8183,12 @@ class Connection {
 
 
   _wsOnLogsNotification(notification) {
-    const res = superstruct.create(notification, LogsNotificationResult);
-    const keys = Object.keys(this._logsSubscriptions).map(Number);
-
-    for (let id of keys) {
-      const sub = this._logsSubscriptions[id];
+    const {
+      result,
+      subscription
+    } = superstruct.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
@@ -8061,14 +8196,12 @@ class Connection {
 
 
   _wsOnSlotNotification(notification) {
-    const res = superstruct.create(notification, SlotNotificationResult);
+    const {
+      result,
+      subscription
+    } = superstruct.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
@@ -8079,33 +8212,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
@@ -8113,14 +8236,12 @@ class Connection {
 
 
   _wsOnSlotUpdatesNotification(notification) {
-    const res = superstruct.create(notification, SlotUpdateNotificationResult);
+    const {
+      result,
+      subscription
+    } = superstruct.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
@@ -8132,32 +8253,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(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.');
     }
   }
 
@@ -8204,30 +8329,34 @@ class Connection {
 
 
   _wsOnSignatureNotification(notification) {
-    const res = superstruct.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
+    } = superstruct.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
@@ -8240,23 +8369,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
@@ -8271,35 +8403,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
@@ -8307,14 +8447,12 @@ class Connection {
 
 
   _wsOnRootNotification(notification) {
-    const res = superstruct.create(notification, RootNotificationResult);
+    const {
+      result,
+      subscription
+    } = superstruct.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
@@ -8325,33 +8463,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');
   }
 
 }
@@ -10055,6 +10183,7 @@ exports.NONCE_ACCOUNT_LENGTH = NONCE_ACCOUNT_LENGTH;
 exports.NonceAccount = NonceAccount;
 exports.PACKET_DATA_SIZE = PACKET_DATA_SIZE;
 exports.PublicKey = PublicKey;
+exports.SIGNATURE_LENGTH_IN_BYTES = SIGNATURE_LENGTH_IN_BYTES;
 exports.SOLANA_SCHEMA = SOLANA_SCHEMA;
 exports.STAKE_CONFIG_ID = STAKE_CONFIG_ID;
 exports.STAKE_INSTRUCTION_LAYOUTS = STAKE_INSTRUCTION_LAYOUTS;