@solana/web3.js 1.66.2 → 1.66.4

package/lib/index.cjs.js

@@ -1863,7 +1863,7 @@ class Transaction {
           return false;
         }
       } else {
-        if (!verify(signature, signData, publicKey.toBuffer())) {
+        if (!verify(signature, signData, publicKey.toBytes())) {
           return false;
         }
       }
@@ -3259,12 +3259,12 @@ class BpfLoader {
     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
    */
@@ -4701,6 +4701,10 @@ class Connection {
 
   /** @internal */
 
+  /** @internal */
+
+  /** @internal */
+
   /**
    * Special case.
    * After a signature is processed, RPCs automatically dispose of the
@@ -4746,6 +4750,8 @@ class Connection {
     };
     this._nextClientSubscriptionId = 0;
     this._subscriptionDisposeFunctionsByClientSubscriptionId = {};
+    this._subscriptionHashByClientSubscriptionId = {};
+    this._subscriptionStateChangeCallbacksByHash = {};
     this._subscriptionCallbacksByServerSubscriptionId = {};
     this._subscriptionsByHash = {};
     this._subscriptionsAutoDisposedByRpc = new Set();
@@ -5275,12 +5281,13 @@ class Connection {
     assert(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
@@ -5291,6 +5298,48 @@ class Connection {
             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);
       }
@@ -5363,8 +5412,12 @@ class Connection {
     } finally {
       clearTimeout(timeoutId);
 
-      if (subscriptionId) {
-        this.removeSignatureListener(subscriptionId);
+      if (disposeSignatureSubscriptionStateChangeObserver) {
+        disposeSignatureSubscriptionStateChangeObserver();
+      }
+
+      if (signatureSubscriptionId) {
+        this.removeSignatureListener(signatureSubscriptionId);
       }
     }
 
@@ -6866,9 +6919,9 @@ class Connection {
 
     this._subscriptionCallbacksByServerSubscriptionId = {};
     Object.entries(this._subscriptionsByHash).forEach(([hash, subscription]) => {
-      this._subscriptionsByHash[hash] = { ...subscription,
+      this._setSubscription(hash, { ...subscription,
         state: 'pending'
-      };
+      });
     });
   }
   /**
@@ -6876,6 +6929,53 @@ class Connection {
    */
 
 
+  _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) {
@@ -6961,14 +7061,17 @@ class Connection {
             } = 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) {
@@ -6981,9 +7084,10 @@ class Connection {
               } // TODO: Maybe add an 'errored' state or a retry limit?
 
 
-              this._subscriptionsByHash[hash] = { ...subscription,
+              this._setSubscription(hash, { ...subscription,
                 state: 'pending'
-              };
+              });
+
               await this._updateSubscriptions();
             }
           })();
@@ -7012,9 +7116,13 @@ class Connection {
                  */
                 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]);
@@ -7028,17 +7136,19 @@ class Connection {
                   } // 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();
             })();
           }
@@ -7131,8 +7241,11 @@ class Connection {
       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(subscription !== undefined, `Could not find a \`Subscription\` when tearing down client subscription #${clientSubscriptionId}`);
       subscription.callbacks.delete(subscriptionConfig.callback);