v13.0.38: fix solana helius rpc queries

Author: 0xNe0x1

dev.html

@@ -18,7 +18,7 @@
     <script crossorigin src="https://cdn.jsdelivr.net/npm/@depay/react-shadow-dom@5"></script>
     <script crossorigin src="https://cdn.jsdelivr.net/npm/@depay/js-verify-signature-web@3"></script>
     <script crossorigin src="https://cdn.jsdelivr.net/npm/@depay/web3-blockchains@9.8.10"></script>
-    <script crossorigin src="https://cdn.jsdelivr.net/npm/@depay/web3-client@11.1.0"></script>
+    <script crossorigin src="https://cdn.jsdelivr.net/npm/@depay/web3-client@11.1.10"></script>
     <script crossorigin src="https://cdn.jsdelivr.net/npm/@depay/web3-tokens@11.1.0"></script>
     <script crossorigin src="https://cdn.jsdelivr.net/npm/@depay/react-token-image@6"></script>
     <script crossorigin src="https://cdn.jsdelivr.net/npm/@depay/coinbase-wallet-sdk@3"></script>

dist/esm/index.bundle.js

@@ -64784,21 +64784,19 @@ const MAX_RETRY$1$1 = 5;
 
 class StaticJsonRpcBatchProvider$1 extends ethers.providers.JsonRpcProvider {
 
-  constructor(url, network, endpoints, failover) {
+  constructor(url, network, endpoints) {
     super(url);
     this._network = network;
     this._endpoint = url;
     this._endpoints = endpoints;
-    this._failover = failover;
     this._pendingBatch = [];
   }
 
-  handleError(error, attempt, chunk) {
+  handleError(error, endpoint, attempt, chunk) {
     if(attempt < MAX_RETRY$1$1 && error) {
-      const index = this._endpoints.indexOf(this._endpoint)+1;
-      this._failover();
-      this._endpoint = index >= this._endpoints.length ? this._endpoints[0] : this._endpoints[index];
-      this.requestChunk(chunk, this._endpoint, attempt+1);
+      const index = this._endpoints.indexOf(endpoint) + 1;
+      const retryWithNextUrl = index >= this._endpoints.length ? this._endpoints[0] : this._endpoints[index];
+      this.requestChunk(chunk, retryWithNextUrl, attempt+1);
     } else {
       chunk.forEach((inflightRequest) => {
         inflightRequest.reject(error);
@@ -64810,13 +64808,13 @@ class StaticJsonRpcBatchProvider$1 extends ethers.providers.JsonRpcProvider {
     return Promise.resolve(Blockchains.findByName(this._network).id)
   }
 
-  batchRequest(batch, attempt) {
+  batchRequest(batch, endpoint, attempt) {
     return new Promise((resolve, reject) => {
 
       if (batch.length === 0) resolve([]); // Do nothing if requests is empty
 
       fetch(
-        this._endpoint,
+        endpoint,
         {
           method: 'POST',
           body: JSON.stringify(batch),
@@ -64826,6 +64824,9 @@ class StaticJsonRpcBatchProvider$1 extends ethers.providers.JsonRpcProvider {
       ).then((response)=>{
         if(response.ok) {
           response.json().then((parsedJson)=>{
+            if(!(parsedJson instanceof Array)) {
+              parsedJson = [parsedJson];
+            }
             if(parsedJson.find((entry)=>{
               return _optionalChain$6$2([entry, 'optionalAccess', _2 => _2.error]) && [-32062,-32016].includes(_optionalChain$6$2([entry, 'optionalAccess', _3 => _3.error, 'optionalAccess', _4 => _4.code]))
             })) {
@@ -64850,7 +64851,7 @@ class StaticJsonRpcBatchProvider$1 extends ethers.providers.JsonRpcProvider {
     const batch = chunk.map((inflight) => inflight.request);
 
     try {
-      return this.batchRequest(batch, attempt)
+      return this.batchRequest(batch, endpoint, attempt)
         .then((result) => {
           // For each result, feed it to the correct Promise, depending
           // on whether it was a success or error
@@ -64867,8 +64868,8 @@ class StaticJsonRpcBatchProvider$1 extends ethers.providers.JsonRpcProvider {
               inflightRequest.reject();
             }
           });
-        }).catch((error) => this.handleError(error, attempt, chunk))
-    } catch (error){ this.handleError(error, attempt, chunk); }
+        }).catch((error) => this.handleError(error, endpoint, attempt, chunk))
+    } catch (error){ this.handleError(error, endpoint, attempt, chunk); }
   }
 
   send(method, params) {
@@ -64940,13 +64941,7 @@ const setProvider$2 = (blockchain, provider)=> {
 const setProviderEndpoints$2 = async (blockchain, endpoints, detectFastest = true)=> {
 
   getAllProviders$1()[blockchain] = endpoints.map((endpoint, index)=>
-    new StaticJsonRpcBatchProvider$1(endpoint, blockchain, endpoints, ()=>{
-      if(getAllProviders$1()[blockchain].length === 1) {
-        setProviderEndpoints$2(blockchain, endpoints, detectFastest);
-      } else {
-        getAllProviders$1()[blockchain].splice(index, 1);
-      }
-    })
+    new StaticJsonRpcBatchProvider$1(endpoint, blockchain, endpoints)
   );
 
   let provider;
@@ -65040,52 +65035,57 @@ const BATCH_INTERVAL = 10;
 const CHUNK_SIZE = 25;
 const MAX_RETRY = 10;
 
+function isHeliusEndpoint(url) {
+  return typeof url === 'string' && url.includes('helius-rpc.com')
+}
+
 class StaticJsonRpcSequentialProvider extends Connection {
 
-  constructor(url, network, endpoints, failover) {
+  constructor(url, network, endpoints) {
     super(url);
-    this._provider = new Connection(url);
     this._network = network;
     this._endpoint = url;
     this._endpoints = endpoints;
-    this._failover = failover;
     this._pendingBatch = [];
+    this._nextId = 1;
+
+    // Solana-specific: replace Connection's internal RPC method so our code batches
     this._rpcRequest = this._rpcRequestReplacement.bind(this);
   }
 
-  handleError(error, attempt, chunk) {
-    if(attempt < MAX_RETRY) {
-      const index = this._endpoints.indexOf(this._endpoint)+1;
-      this._endpoint = index >= this._endpoints.length ? this._endpoints[0] : this._endpoints[index];
-      this._provider = new Connection(this._endpoint);
-      this.requestChunk(chunk, attempt+1);
+  handleError(error, endpoint, attempt, chunk) {
+    if(attempt < MAX_RETRY && error) {
+      const index = this._endpoints.indexOf(endpoint) + 1;
+      const retryWithNextUrl = index >= this._endpoints.length ? this._endpoints[0] : this._endpoints[index];
+      this.requestChunk(chunk, retryWithNextUrl, attempt+1);
     } else {
       chunk.forEach((inflightRequest) => {
         inflightRequest.reject(error);
       });
     }
   }
 
-  batchRequest(requests, attempt) {
+  // Same shape as ETH batchRequest, but we don’t special-case error codes here.
+  batchRequest(batch, endpoint, attempt) {
     return new Promise((resolve, reject) => {
-      if (requests.length === 0) resolve([]); // Do nothing if requests is empty
-
-      const batch = requests.map(params => {
-        return this._rpcClient.request(params.methodName, params.args)
-      });
+      
+      if (batch.length === 0) resolve([]); // Do nothing if requests is empty
 
       fetch(
-        this._endpoint,
+        endpoint,
         {
           method: 'POST',
           body: JSON.stringify(batch),
           headers: { 'Content-Type': 'application/json' },
-          signal: _optionalChain$4$2([AbortSignal, 'optionalAccess', _ => _.timeout]) ? AbortSignal.timeout(60000) : undefined  // 60-second timeout
+          signal: _optionalChain$4$2([AbortSignal, 'optionalAccess', _ => _.timeout]) ? AbortSignal.timeout(10000) : undefined  // 10-second timeout
         }
       ).then((response)=>{
         if(response.ok) {
           response.json().then((parsedJson)=>{
-            if(parsedJson.find((entry)=>_optionalChain$4$2([entry, 'optionalAccess', _2 => _2.error]))) {
+            if(!(parsedJson instanceof Array)) {
+              parsedJson = [parsedJson];
+            }
+            if(parsedJson.find((entry)=> _optionalChain$4$2([entry, 'optionalAccess', _2 => _2.error]) )) {
               if(attempt < MAX_RETRY) {
                 reject('Error in batch found!');
               } else {
@@ -65102,13 +65102,14 @@ class StaticJsonRpcSequentialProvider extends Connection {
     })
   }
 
-  requestChunk(chunk, attempt) {
+  requestChunk(chunk, endpoint, attempt) {
 
     const batch = chunk.map((inflight) => inflight.request);
 
     try {
-      return this.batchRequest(batch, attempt)
+      return this.batchRequest(batch, endpoint, attempt)
         .then((result) => {
+          // For each result, feed it to the correct Promise
           chunk.forEach((inflightRequest, index) => {
             const payload = result[index];
             if (_optionalChain$4$2([payload, 'optionalAccess', _3 => _3.error])) {
@@ -65117,18 +65118,25 @@ class StaticJsonRpcSequentialProvider extends Connection {
               error.data = payload.error.data;
               inflightRequest.reject(error);
             } else if(payload) {
+              // Solana-specific: resolve with full JSON-RPC payload (not .result)
               inflightRequest.resolve(payload);
             } else {
               inflightRequest.reject();
             }
           });
-        }).catch((error)=>this.handleError(error, attempt, chunk))
-    } catch (error){ return this.handleError(error, attempt, chunk) }
+        }).catch((error) => this.handleError(error, endpoint, attempt, chunk))
+    } catch (error){ this.handleError(error, endpoint, attempt, chunk); }
   }
-    
-  _rpcRequestReplacement(methodName, args) {
 
-    const request = { methodName, args };
+  // Solana-specific replacement: just enqueue like ETH's send(), but using Connection’s hook.
+  _rpcRequestReplacement(method, params) {
+
+    const request = {
+      method: method,
+      params: Array.isArray(params) ? params : [],
+      id: (this._nextId++).toString(),
+      jsonrpc: "2.0"
+    };
 
     if (this._pendingBatch == null) {
       this._pendingBatch = [];
@@ -65151,16 +65159,39 @@ class StaticJsonRpcSequentialProvider extends Connection {
         const batch = this._pendingBatch;
         this._pendingBatch = [];
         this._pendingBatchAggregator = null;
-        // Prepare Chunks of CHUNK_SIZE
-        const chunks = [];
-        for (let i = 0; i < Math.ceil(batch.length / CHUNK_SIZE); i++) {
-          chunks[i] = batch.slice(i*CHUNK_SIZE, (i+1)*CHUNK_SIZE);
+
+        const endpoint = this._endpoint;
+        const helius = isHeliusEndpoint(endpoint);
+
+        if (helius) {
+          // Requirement 1: For helius-rpc.com, batch only requests that share the same method
+          const groupsByMethod = batch.reduce((acc, inflight) => {
+            const m = inflight.request.method;
+            if (!acc[m]) acc[m] = [];
+            acc[m].push(inflight);
+            return acc
+          }, {});
+
+          Object.values(groupsByMethod).forEach((group) => {
+            // CHUNK_SIZE still applies within each method group
+            const chunks = [];
+            for (let i = 0; i < Math.ceil(group.length / CHUNK_SIZE); i++) {
+              chunks[i] = group.slice(i*CHUNK_SIZE, (i+1)*CHUNK_SIZE);
+            }
+            chunks.forEach((chunk)=>{
+              return this.requestChunk(chunk, endpoint, 1)
+            });
+          });
+        } else {
+          // Default behavior (unchanged): chunk regardless of method
+          const chunks = [];
+          for (let i = 0; i < Math.ceil(batch.length / CHUNK_SIZE); i++) {
+            chunks[i] = batch.slice(i*CHUNK_SIZE, (i+1)*CHUNK_SIZE);
+          }
+          chunks.forEach((chunk)=>{
+            return this.requestChunk(chunk, endpoint, 1)
+          });
         }
-        chunks.forEach((chunk)=>{
-          // Get the request as an array of requests
-          chunk.map((inflight) => inflight.request);
-          return this.requestChunk(chunk, 1)
-        });
       }, getConfiguration$1().batchInterval || BATCH_INTERVAL);
     }
 
@@ -65189,13 +65220,7 @@ const setProvider$1 = (blockchain, provider)=> {
 const setProviderEndpoints$1 = async (blockchain, endpoints, detectFastest = true)=> {
 
   getAllProviders()[blockchain] = endpoints.map((endpoint, index)=>
-    new StaticJsonRpcSequentialProvider(endpoint, blockchain, endpoints, ()=>{
-      if(getAllProviders()[blockchain].length === 1) {
-        setProviderEndpoints$1(blockchain, endpoints, detectFastest);
-      } else {
-        getAllProviders()[blockchain].splice(index, 1);
-      }
-    })
+    new StaticJsonRpcSequentialProvider(endpoint, blockchain, endpoints)
   );
 
   let provider;
@@ -65225,8 +65250,8 @@ const setProviderEndpoints$1 = async (blockchain, endpoints, detectFastest = tru
             },
             referrer: "",
             referrerPolicy: "no-referrer",
-            body: JSON.stringify({ method: 'getIdentity', id: 1, jsonrpc: '2.0' }),
-            signal: _optionalChain$3$2([AbortSignal, 'optionalAccess', _ => _.timeout]) ? AbortSignal.timeout(60000) : undefined  // 60-second timeout
+            body: JSON.stringify({ method: 'getGenesisHash', id: 1, jsonrpc: '2.0' }),
+            signal: _optionalChain$3$2([AbortSignal, 'optionalAccess', _ => _.timeout]) ? AbortSignal.timeout(10000) : undefined  // 10-second timeout
           });
         } catch (e) {}
         if(!_optionalChain$3$2([response, 'optionalAccess', _2 => _2.ok])) { return resolve(999) }
@@ -65446,8 +65471,8 @@ const contractCall = ({ address, api, method, params, provider, block }) => {
   }
 };
 
-const balance$1 = ({ address, provider }) => {
-  return provider.getBalance(address)
+const balance$1 = ({ address, provider, block }) => {
+  return provider.getBalance(address, block)
 };
 
 const transactionCount = ({ address, provider }) => {
@@ -65460,7 +65485,7 @@ const singleRequest$3 = ({ blockchain, address, api, method, params, block, prov
   } else if (method === 'latestBlockNumber') {
     return provider.getBlockNumber()
   } else if (method === 'balance') {
-    return balance$1({ address, provider })
+    return balance$1({ address, provider, block })
   } else if (method === 'transactionCount') {
     return transactionCount({ address, provider })
   }
@@ -65546,14 +65571,7 @@ const singleRequest$2 = async({ blockchain, address, api, method, params, block,
     }
 
   } catch (error){
-    if(providers && error && [
-      'Failed to fetch', 'limit reached', '504', '503', '502', '500', '429', '426', '422', '413', '409', '408', '406', '405', '404', '403', '402', '401', '400'
-    ].some((errorType)=>error.toString().match(errorType))) {
-      let nextProvider = providers[providers.indexOf(provider)+1] || providers[0];
-      return singleRequest$2({ blockchain, address, api, method, params, block, provider: nextProvider, providers })
-    } else {
-      throw error
-    }
+    throw error
   }
 };