@solana/web3.js 1.41.1 → 1.41.4

package/lib/index.cjs.js

@@ -8,7 +8,7 @@ var BN = require('bn.js');
 var bs58 = require('bs58');
 var borsh = require('borsh');
 var BufferLayout = require('@solana/buffer-layout');
-var crossFetch = require('cross-fetch');
+var fetch = require('cross-fetch');
 var superstruct = require('superstruct');
 var rpcWebsockets = require('rpc-websockets');
 var RpcClient = require('jayson/lib/client/browser');
@@ -41,7 +41,7 @@ var nacl__default = /*#__PURE__*/_interopDefaultLegacy(nacl);
 var BN__default = /*#__PURE__*/_interopDefaultLegacy(BN);
 var bs58__default = /*#__PURE__*/_interopDefaultLegacy(bs58);
 var BufferLayout__namespace = /*#__PURE__*/_interopNamespace(BufferLayout);
-var crossFetch__default = /*#__PURE__*/_interopDefaultLegacy(crossFetch);
+var fetch__default = /*#__PURE__*/_interopDefaultLegacy(fetch);
 var RpcClient__default = /*#__PURE__*/_interopDefaultLegacy(RpcClient);
 var http__default = /*#__PURE__*/_interopDefaultLegacy(http);
 var https__default = /*#__PURE__*/_interopDefaultLegacy(https);
@@ -3111,6 +3111,106 @@ 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 node = {};
+
+Object.defineProperty(node, "__esModule", { value: true });
+let converter;
+{
+    try {
+        converter = require('bindings')('bigint_buffer');
+    }
+    catch (e) {
+        console.warn('bigint: Failed to load bindings, pure JS will be used (try npm run rebuild?)');
+    }
+}
+/**
+ * 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) {
+    if (converter === undefined) {
+        const reversed = Buffer.from(buf);
+        reversed.reverse();
+        const hex = reversed.toString('hex');
+        if (hex.length === 0) {
+            return BigInt(0);
+        }
+        return BigInt(`0x${hex}`);
+    }
+    return converter.toBigInt(buf, false);
+}
+var toBigIntLE_1 = node.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) {
+    if (converter === undefined) {
+        const hex = buf.toString('hex');
+        if (hex.length === 0) {
+            return BigInt(0);
+        }
+        return BigInt(`0x${hex}`);
+    }
+    return converter.toBigInt(buf, true);
+}
+node.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) {
+    if (converter === undefined) {
+        const hex = num.toString(16);
+        const buffer = Buffer.from(hex.padStart(width * 2, '0').slice(0, width * 2), 'hex');
+        buffer.reverse();
+        return buffer;
+    }
+    // Allocation is done here, since it is slower using napi in C
+    return converter.fromBigInt(num, Buffer.allocUnsafe(width), false);
+}
+var toBufferLE_1 = node.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) {
+    if (converter === undefined) {
+        const hex = num.toString(16);
+        return Buffer.from(hex.padStart(width * 2, '0').slice(0, width * 2), 'hex');
+    }
+    return converter.fromBigInt(num, Buffer.allocUnsafe(width), true);
+}
+node.toBufferBE = toBufferBE;
+
+const bigInt = (length) => (property) => {
+    const layout = BufferLayout.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
@@ -3500,7 +3600,7 @@ const SYSTEM_INSTRUCTION_LAYOUTS = Object.freeze({
   },
   Transfer: {
     index: 2,
-    layout: BufferLayout__namespace.struct([BufferLayout__namespace.u32('instruction'), BufferLayout__namespace.ns64('lamports')])
+    layout: BufferLayout__namespace.struct([BufferLayout__namespace.u32('instruction'), u64('lamports')])
   },
   CreateWithSeed: {
     index: 3,
@@ -3536,7 +3636,7 @@ const SYSTEM_INSTRUCTION_LAYOUTS = Object.freeze({
   },
   TransferWithSeed: {
     index: 11,
-    layout: BufferLayout__namespace.struct([BufferLayout__namespace.u32('instruction'), BufferLayout__namespace.ns64('lamports'), rustString('seed'), publicKey('programId')])
+    layout: BufferLayout__namespace.struct([BufferLayout__namespace.u32('instruction'), u64('lamports'), rustString('seed'), publicKey('programId')])
   }
 });
 /**
@@ -3589,7 +3689,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())
       });
@@ -3609,7 +3709,7 @@ class SystemProgram {
     } else {
       const type = SYSTEM_INSTRUCTION_LAYOUTS.Transfer;
       data = encodeData(type, {
-        lamports: params.lamports
+        lamports: BigInt(params.lamports)
       });
       keys = [{
         pubkey: params.fromPubkey,
@@ -4244,6 +4344,82 @@ class ComputeBudgetProgram {
 }
 ComputeBudgetProgram.programId = new PublicKey('ComputeBudget111111111111111111111111111111');
 
+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 DESTROY_TIMEOUT_MS = 5000;
 class AgentManager {
   static _newAgent(useHttps) {
@@ -4459,6 +4635,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
@@ -4629,7 +4811,7 @@ const BlockProductionResponseStruct = jsonRpcResultAndContext(superstruct.type({
  */
 
 function createRpcClient(url, useHttps, httpHeaders, customFetch, fetchMiddleware, disableRetryOnRateLimit) {
-  const fetch = customFetch ? customFetch : crossFetch__default["default"];
+  const fetch = customFetch ? customFetch : fetch__default["default"];
   let agentManager;
 
   {
@@ -5333,14 +5515,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 */
 
@@ -5364,21 +5541,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 */
 
@@ -5394,7 +5563,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 */
 
@@ -5416,6 +5597,7 @@ class Connection {
     this._rpcWebSocketConnected = false;
     this._rpcWebSocketHeartbeat = null;
     this._rpcWebSocketIdleTimeout = null;
+    this._rpcWebSocketGeneration = 0;
     this._disableBlockhashCaching = false;
     this._pollingBlockhash = false;
     this._blockhashInfo = {
@@ -5424,20 +5606,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;
@@ -7205,6 +7378,8 @@ class Connection {
 
 
   _wsOnClose(code) {
+    this._rpcWebSocketGeneration++;
+
     if (this._rpcWebSocketHeartbeat) {
       clearInterval(this._rpcWebSocketHeartbeat);
       this._rpcWebSocketHeartbeat = null;
@@ -7218,85 +7393,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(() => {
@@ -7328,60 +7438,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'));
-    }
+    const isCurrentConnectionStillActive = () => {
+      return activeWebSocketGeneration === this._rpcWebSocketGeneration;
+    };
 
-    for (let id of programKeys) {
-      const sub = this._programAccountChangeSubscriptions[id];
+    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];
 
-      this._subscribe(sub, 'programSubscribe', this._buildArgs([sub.programId], sub.commitment, 'base64', {
-        filters: sub.filters
-      }));
-    }
-
-    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
@@ -7389,14 +7606,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
@@ -7409,35 +7683,24 @@ class Connection {
 
 
   onAccountChange(publicKey, callback, commitment) {
-    const id = ++this._accountChangeSubscriptionCounter;
-    this._accountChangeSubscriptions[id] = {
-      publicKey: publicKey.toBase58(),
-      callback,
-      commitment,
-      subscriptionId: null
-    };
-
-    this._updateSubscriptions();
+    const args = this._buildArgs([publicKey.toBase58()], commitment || this._commitment || 'finalized', // Apply connection/server default.
+    'base64');
 
-    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
@@ -7445,21 +7708,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
@@ -7474,36 +7731,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.
@@ -7511,35 +7762,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
@@ -7547,17 +7789,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
@@ -7565,14 +7802,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
@@ -7583,33 +7818,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
@@ -7617,14 +7842,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
@@ -7636,32 +7859,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.');
     }
   }
 
@@ -7708,30 +7935,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
@@ -7744,23 +7975,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
@@ -7775,35 +8009,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
@@ -7811,14 +8053,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
@@ -7829,33 +8069,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');
   }
 
 }
@@ -9557,7 +9787,9 @@ exports.MAX_SEED_LENGTH = MAX_SEED_LENGTH;
 exports.Message = Message;
 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;