@solana/web3.js 1.66.1 → 1.66.3

package/README.md

@@ -1,4 +1,3 @@
-[![Build status][travis-image]][travis-url]
 [![codecov][codecov-image]][codecov-url]
 <br>
 [![npm][npm-image]][npm-url]
@@ -7,8 +6,6 @@
 [![semantic-release][semantic-release-image]][semantic-release-url]
 [![code-style-prettier][code-style-prettier-image]][code-style-prettier-url]
 
-[travis-image]: https://api.travis-ci.org/solana-labs/solana-web3.js.svg?branch=master
-[travis-url]: https://travis-ci.org/solana-labs/solana-web3.js
 [codecov-image]: https://codecov.io/gh/solana-labs/solana-web3.js/branch/master/graph/badge.svg
 [codecov-url]: https://codecov.io/gh/solana-labs/solana-web3.js
 [npm-image]: https://img.shields.io/npm/v/@solana/web3.js.svg?style=flat
@@ -60,7 +57,7 @@ Install the latest Solana release from https://docs.solana.com/cli/install-solan
 
 **Use `solana-test-validator` from the latest Solana release**
 
-### BPF program development
+### SBF program development
 
 **Use `cargo build-bpf` from the latest Solana release**
 

package/lib/index.browser.cjs.js

@@ -3253,12 +3253,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
    */
@@ -4635,6 +4635,10 @@ class Connection {
 
   /** @internal */
 
+  /** @internal */
+
+  /** @internal */
+
   /**
    * Special case.
    * After a signature is processed, RPCs automatically dispose of the
@@ -4680,6 +4684,8 @@ class Connection {
     };
     this._nextClientSubscriptionId = 0;
     this._subscriptionDisposeFunctionsByClientSubscriptionId = {};
+    this._subscriptionHashByClientSubscriptionId = {};
+    this._subscriptionStateChangeCallbacksByHash = {};
     this._subscriptionCallbacksByServerSubscriptionId = {};
     this._subscriptionsByHash = {};
     this._subscriptionsAutoDisposedByRpc = new Set();
@@ -5209,12 +5215,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
@@ -5225,6 +5232,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);
       }
@@ -5297,8 +5346,12 @@ class Connection {
     } finally {
       clearTimeout(timeoutId);
 
-      if (subscriptionId) {
-        this.removeSignatureListener(subscriptionId);
+      if (disposeSignatureSubscriptionStateChangeObserver) {
+        disposeSignatureSubscriptionStateChangeObserver();
+      }
+
+      if (signatureSubscriptionId) {
+        this.removeSignatureListener(signatureSubscriptionId);
       }
     }
 
@@ -5673,7 +5726,7 @@ class Connection {
     const res = superstruct.create(unsafeRes, jsonRpcResultAndContext(superstruct.nullable(superstruct.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) {
@@ -6800,9 +6853,9 @@ class Connection {
 
     this._subscriptionCallbacksByServerSubscriptionId = {};
     Object.entries(this._subscriptionsByHash).forEach(([hash, subscription]) => {
-      this._subscriptionsByHash[hash] = { ...subscription,
+      this._setSubscription(hash, { ...subscription,
         state: 'pending'
-      };
+      });
     });
   }
   /**
@@ -6810,6 +6863,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) {
@@ -6895,14 +6995,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) {
@@ -6915,9 +7018,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();
             }
           })();
@@ -6946,9 +7050,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]);
@@ -6962,17 +7070,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();
             })();
           }
@@ -7065,8 +7175,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);