@solana/web3.js 1.66.1 → 1.66.3

package/lib/index.iife.js

@@ -13775,12 +13775,12 @@ var solanaWeb3 = (function (exports) {
 	    return Loader.getMinNumSignatures(dataLength);
 	  }
 	  /**
-	   * Load a BPF program
+	   * Load a SBF program
 	   *
 	   * @param connection The connection to use
 	   * @param payer Account that will pay program loading fees
 	   * @param program Account to load the program into
-	   * @param elf The entire ELF containing the BPF program
+	   * @param elf The entire ELF containing the SBF program
 	   * @param loaderProgramId The program id of the BPF loader to use
 	   * @return true if program was loaded successfully, false if program was already loaded
 	   */
@@ -18258,6 +18258,10 @@ var solanaWeb3 = (function (exports) {
 
 	  /** @internal */
 
+	  /** @internal */
+
+	  /** @internal */
+
 	  /**
 	   * Special case.
 	   * After a signature is processed, RPCs automatically dispose of the
@@ -18303,6 +18307,8 @@ var solanaWeb3 = (function (exports) {
 	    };
 	    this._nextClientSubscriptionId = 0;
 	    this._subscriptionDisposeFunctionsByClientSubscriptionId = {};
+	    this._subscriptionHashByClientSubscriptionId = {};
+	    this._subscriptionStateChangeCallbacksByHash = {};
 	    this._subscriptionCallbacksByServerSubscriptionId = {};
 	    this._subscriptionsByHash = {};
 	    this._subscriptionsAutoDisposedByRpc = new Set();
@@ -18832,12 +18838,13 @@ var solanaWeb3 = (function (exports) {
 	    assert$1(decodedSignature.length === 64, 'signature has invalid length');
 	    const subscriptionCommitment = commitment || this.commitment;
 	    let timeoutId;
-	    let subscriptionId;
+	    let signatureSubscriptionId;
+	    let disposeSignatureSubscriptionStateChangeObserver;
 	    let done = false;
 	    const confirmationPromise = new Promise((resolve, reject) => {
 	      try {
-	        subscriptionId = this.onSignature(rawSignature, (result, context) => {
-	          subscriptionId = undefined;
+	        signatureSubscriptionId = this.onSignature(rawSignature, (result, context) => {
+	          signatureSubscriptionId = undefined;
 	          const response = {
 	            context,
 	            value: result
@@ -18848,6 +18855,48 @@ var solanaWeb3 = (function (exports) {
 	            response
 	          });
 	        }, subscriptionCommitment);
+	        const subscriptionSetupPromise = new Promise(resolveSubscriptionSetup => {
+	          if (signatureSubscriptionId == null) {
+	            resolveSubscriptionSetup();
+	          } else {
+	            disposeSignatureSubscriptionStateChangeObserver = this._onSubscriptionStateChange(signatureSubscriptionId, nextState => {
+	              if (nextState === 'subscribed') {
+	                resolveSubscriptionSetup();
+	              }
+	            });
+	          }
+	        });
+
+	        (async () => {
+	          await subscriptionSetupPromise;
+	          if (done) return;
+	          const response = await this.getSignatureStatus(rawSignature);
+	          if (done) return;
+
+	          if (response == null) {
+	            return;
+	          }
+
+	          const {
+	            context,
+	            value
+	          } = response;
+
+	          if (value !== null && value !== void 0 && value.err) {
+	            reject(value.err);
+	          }
+
+	          if (value) {
+	            done = true;
+	            resolve({
+	              __type: exports.TransactionStatus.PROCESSED,
+	              response: {
+	                context,
+	                value
+	              }
+	            });
+	          }
+	        })();
 	      } catch (err) {
 	        reject(err);
 	      }
@@ -18920,8 +18969,12 @@ var solanaWeb3 = (function (exports) {
 	    } finally {
 	      clearTimeout(timeoutId);
 
-	      if (subscriptionId) {
-	        this.removeSignatureListener(subscriptionId);
+	      if (disposeSignatureSubscriptionStateChangeObserver) {
+	        disposeSignatureSubscriptionStateChangeObserver();
+	      }
+
+	      if (signatureSubscriptionId) {
+	        this.removeSignatureListener(signatureSubscriptionId);
 	      }
 	    }
 
@@ -19296,7 +19349,7 @@ var solanaWeb3 = (function (exports) {
 	    const res = create(unsafeRes, jsonRpcResultAndContext(nullable(number())));
 
 	    if ('error' in res) {
-	      throw new SolanaJSONRPCError(res.error, 'failed to get slot');
+	      throw new SolanaJSONRPCError(res.error, 'failed to get fee for message');
 	    }
 
 	    if (res.result === null) {
@@ -20423,9 +20476,9 @@ var solanaWeb3 = (function (exports) {
 
 	    this._subscriptionCallbacksByServerSubscriptionId = {};
 	    Object.entries(this._subscriptionsByHash).forEach(([hash, subscription]) => {
-	      this._subscriptionsByHash[hash] = { ...subscription,
+	      this._setSubscription(hash, { ...subscription,
 	        state: 'pending'
-	      };
+	      });
 	    });
 	  }
 	  /**
@@ -20433,6 +20486,53 @@ var solanaWeb3 = (function (exports) {
 	   */
 
 
+	  _setSubscription(hash, nextSubscription) {
+	    var _this$_subscriptionsB;
+
+	    const prevState = (_this$_subscriptionsB = this._subscriptionsByHash[hash]) === null || _this$_subscriptionsB === void 0 ? void 0 : _this$_subscriptionsB.state;
+	    this._subscriptionsByHash[hash] = nextSubscription;
+
+	    if (prevState !== nextSubscription.state) {
+	      const stateChangeCallbacks = this._subscriptionStateChangeCallbacksByHash[hash];
+
+	      if (stateChangeCallbacks) {
+	        stateChangeCallbacks.forEach(cb => {
+	          try {
+	            cb(nextSubscription.state); // eslint-disable-next-line no-empty
+	          } catch {}
+	        });
+	      }
+	    }
+	  }
+	  /**
+	   * @internal
+	   */
+
+
+	  _onSubscriptionStateChange(clientSubscriptionId, callback) {
+	    var _this$_subscriptionSt;
+
+	    const hash = this._subscriptionHashByClientSubscriptionId[clientSubscriptionId];
+
+	    if (hash == null) {
+	      return () => {};
+	    }
+
+	    const stateChangeCallbacks = (_this$_subscriptionSt = this._subscriptionStateChangeCallbacksByHash)[hash] || (_this$_subscriptionSt[hash] = new Set());
+	    stateChangeCallbacks.add(callback);
+	    return () => {
+	      stateChangeCallbacks.delete(callback);
+
+	      if (stateChangeCallbacks.size === 0) {
+	        delete this._subscriptionStateChangeCallbacksByHash[hash];
+	      }
+	    };
+	  }
+	  /**
+	   * @internal
+	   */
+
+
 	  async _updateSubscriptions() {
 	    if (Object.keys(this._subscriptionsByHash).length === 0) {
 	      if (this._rpcWebSocketConnected) {
@@ -20518,14 +20618,17 @@ var solanaWeb3 = (function (exports) {
 	            } = subscription;
 
 	            try {
-	              this._subscriptionsByHash[hash] = { ...subscription,
+	              this._setSubscription(hash, { ...subscription,
 	                state: 'subscribing'
-	              };
+	              });
+
 	              const serverSubscriptionId = await this._rpcWebSocket.call(method, args);
-	              this._subscriptionsByHash[hash] = { ...subscription,
+
+	              this._setSubscription(hash, { ...subscription,
 	                serverSubscriptionId,
 	                state: 'subscribed'
-	              };
+	              });
+
 	              this._subscriptionCallbacksByServerSubscriptionId[serverSubscriptionId] = subscription.callbacks;
 	              await this._updateSubscriptions();
 	            } catch (e) {
@@ -20538,9 +20641,10 @@ var solanaWeb3 = (function (exports) {
 	              } // TODO: Maybe add an 'errored' state or a retry limit?
 
 
-	              this._subscriptionsByHash[hash] = { ...subscription,
+	              this._setSubscription(hash, { ...subscription,
 	                state: 'pending'
-	              };
+	              });
+
 	              await this._updateSubscriptions();
 	            }
 	          })();
@@ -20569,9 +20673,13 @@ var solanaWeb3 = (function (exports) {
 	                 */
 	                this._subscriptionsAutoDisposedByRpc.delete(serverSubscriptionId);
 	              } else {
-	                this._subscriptionsByHash[hash] = { ...subscription,
+	                this._setSubscription(hash, { ...subscription,
+	                  state: 'unsubscribing'
+	                });
+
+	                this._setSubscription(hash, { ...subscription,
 	                  state: 'unsubscribing'
-	                };
+	                });
 
 	                try {
 	                  await this._rpcWebSocket.call(unsubscribeMethod, [serverSubscriptionId]);
@@ -20585,17 +20693,19 @@ var solanaWeb3 = (function (exports) {
 	                  } // TODO: Maybe add an 'errored' state or a retry limit?
 
 
-	                  this._subscriptionsByHash[hash] = { ...subscription,
+	                  this._setSubscription(hash, { ...subscription,
 	                    state: 'subscribed'
-	                  };
+	                  });
+
 	                  await this._updateSubscriptions();
 	                  return;
 	                }
 	              }
 
-	              this._subscriptionsByHash[hash] = { ...subscription,
+	              this._setSubscription(hash, { ...subscription,
 	                state: 'unsubscribed'
-	              };
+	              });
+
 	              await this._updateSubscriptions();
 	            })();
 	          }
@@ -20688,8 +20798,11 @@ var solanaWeb3 = (function (exports) {
 	      existingSubscription.callbacks.add(subscriptionConfig.callback);
 	    }
 
+	    this._subscriptionHashByClientSubscriptionId[clientSubscriptionId] = hash;
+
 	    this._subscriptionDisposeFunctionsByClientSubscriptionId[clientSubscriptionId] = async () => {
 	      delete this._subscriptionDisposeFunctionsByClientSubscriptionId[clientSubscriptionId];
+	      delete this._subscriptionHashByClientSubscriptionId[clientSubscriptionId];
 	      const subscription = this._subscriptionsByHash[hash];
 	      assert$1(subscription !== undefined, `Could not find a \`Subscription\` when tearing down client subscription #${clientSubscriptionId}`);
 	      subscription.callbacks.delete(subscriptionConfig.callback);