Yes, you are not aloneothers have reported issues with the Sui mainnet RPC endpoints, especially when using public endpoints or during periods of high network activity.

Key Points from Context

• Public RPC endpoints maintained by Mysten Labs (e.g., fullnode.<NETWORK>.sui.io:443) are rate-limited and only support 100 requests per 30 seconds.

  "Do not use public endpoints in production applications with high traffic volume."
  (Source)

• Performance issues (such as slow queries or timeouts) are common when:

  • The endpoint is overloaded (many users, bots, or high-traffic apps).
  • You are using filters like FromAddress on large datasets, which are more resource-intensive.
  • The network is experiencing high transaction volume or temporary congestion.

• Recommended Solution:
  For production or high-traffic use, run your own full node or use a professional infrastructure provider.

  "You can either run your own Full nodes, or outsource this to a professional infrastructure provider (preferred for apps that have high traffic)."
  (Source)

• Temporary or Ongoing?
  These slowdowns can be temporary (due to network spikes or maintenance), but if you consistently see high latency, it's likely due to rate limits or public endpoint overload.

What You Can Do

• Switch to a private or dedicated RPC provider (see Sui Dev Portal Node Service tag).
• Reduce query frequency or batch requests where possible.
• Monitor Sui status channels (Discord, forums) for outage or maintenance announcements.

References:

• Sui RPC Best Practices
• Sui Dev Portal: Node Service Providers

Increased latency in Sui mainnet RPC endpoints, such as suix_queryTransactionBlocks with a FromAddress filter taking 20 seconds or execute_transaction delays up to 5 seconds, is a known issue often caused by high query load and index database bottlenecks. The FromAddress filter requires scanning large amounts of indexed data, which can slow down under peak usage. This is typically temporary and improves as infrastructure is optimized. To mitigate, use pagination (limit parameter), avoid overly broad queries, and consider using a dedicated RPC endpoint or a third-party provider with higher rate limits. Sui Founrsation and node operators continuously monitor and scale the network to improve performance.

If you’re experiencing slow response times or high latency when querying the Sui Mainnet RPC endpoint, like with suix_queryTransactionBlocks or fromAddress filters taking 20s or sui_client.execute_transaction taking up to 5s, it could be due to several factors. While this may sometimes be a temporary problem, there are a few common causes and steps you can take to diagnose and potentially resolve the issue.

Potential Causes of Slow Response Times

1. Network Congestion or RPC Overload

   • Cause: The Sui Mainnet RPC endpoint might be experiencing high traffic due to an increase in the number of active users, transactions, or dApps. This can lead to temporary slowdowns as the RPC server struggles to handle all incoming requests.
   • Solution: It's a good idea to check if this is a temporary issue by monitoring the network or looking for status reports from Sui’s official communication channels, such as their GitHub, Discord, or Twitter.

2. Resource Exhaustion on RPC Nodes

   • Cause: If you're using a non-public RPC or even public Sui RPCs, the node's underlying resources (such as CPU, memory, or bandwidth) could be exhausted, leading to slow query responses or transaction execution times.
   • Solution: Test the performance with different RPC endpoints. Switch to a more stable, public RPC if you're using a private one, or try querying from multiple RPC endpoints to see if the issue persists across different nodes.

3. Sui Node Synchronization Delay

   • Cause: RPC endpoints rely on nodes to stay in sync with the blockchain. If a node falls behind or faces synchronization issues, this can result in slow query responses or delayed transaction execution.
   • Solution: Check the node status for any syncing issues. You can monitor the Sui explorer or directly query a node’s health using the Sui CLI to see if there are discrepancies.

4. Large Query or Complex Filters

   • Cause: Queries like suix_queryTransactionBlocks or using complex filters like fromAddress can be computationally expensive if there is a large amount of historical data to sift through.

   • Solution: If possible, reduce the complexity of your queries by narrowing down the range of data you're requesting. For example:

     • Use a time range filter or transaction limit to reduce the query size.
     • Paginate large queries so you’re not querying too much data at once.

     Example: For transaction queries, use:

     sui client query --start 0 --limit 1000 --from-address <address>
     

5. Increased Latency or DDoS Mitigation

   • Cause: There could be temporary increased latency due to DDoS mitigation measures or server-side throttling from the Sui network, especially if the network is facing unusually high load.
   • Solution: In this case, the issue might resolve on its own once the traffic spikes subside. Check Sui's official channels for updates on any ongoing issues related to RPC or network congestion.

6. Sui Mainnet RPC Issues (Temporary Problems)

   • Cause: It could be a temporary issue specific to Sui’s mainnet RPC infrastructure, such as a temporary outage or degraded performance from the Sui validators.
   • Solution: Monitor official Sui channels for maintenance announcements or known issues. Temporary performance issues are often resolved quickly, especially with high-availability systems.

Steps to Diagnose and Resolve the Issue

1. Check Sui’s Status:

   • Visit Sui’s official channels (GitHub, Discord, Twitter, or the status page) to see if there are any ongoing issues with the Mainnet RPC endpoint.

2. Test with Different RPCs:

   • If you're using a non-public RPC, try switching to an official public RPC endpoint or use multiple endpoints to check whether the issue persists across different nodes.

   • You can try using the official Sui testnet RPC endpoint for comparison to see if the issue is specific to the Mainnet RPC:

     sui client set --rpc-url <testnet-rpc-url>
     

3. Reduce Query Complexity:

   • Try to simplify your queries to see if the issue is related to the complexity or size of the data being queried. For instance, try running smaller queries by reducing filters, using fewer transaction blocks, or setting a smaller page size.

4. Monitor RPC Usage:

   • If you’re running your own RPC node, monitor its health and ensure that it’s not running into resource limitations like memory or CPU bottlenecks.
   • Use tools like htop or top to check the server performance if you are managing your own node.

5. Check for Timeouts:

   • In some cases, setting higher timeouts for RPC requests or increasing the timeout settings on your client might help mitigate delays:

     const suiClient = new SuiClient({ rpcUrl: 'https://rpc.sui.io', timeout: 10000 });  // Increase timeout
     

6. Implement Retry Logic:

   • If you are experiencing intermittent failures or slow responses, implement retry logic in your TypeScript SDK client to automatically retry failed queries.
   • Use exponential backoff strategies to prevent overloading the RPC endpoint in case of temporary failures.

Example of Retry Logic in TypeScript SDK:

const retryQuery = async (client, query, retries = 3) => {
    let attempts = 0;
    while (attempts < retries) {
        try {
            const result = await client.queryTransactionBlocks(query);
            return result;
        } catch (error) {
            console.error(`Attempt ${attempts + 1} failed:`, error);
            attempts++;
            if (attempts >= retries) {
                throw new Error('Failed to query after multiple attempts');
            }
            // Exponential backoff
            await new Promise(res => setTimeout(res, Math.pow(2, attempts) * 1000));
        }
    }
};

Conclusion

If your Sui Mainnet RPC endpoint is experiencing slow performance or failures, it could be caused by several factors such as network congestion, node resource limitations, query complexity, or temporary issues with the Sui network. Here’s a summary of steps you can take:

• Check official status channels for known issues.
• Try different RPC endpoints, including official public ones.
• Simplify your queries and reduce the complexity of filters.
• Increase the timeout for RPC requests and implement retry logic.
• Monitor the node health if you're using a custom RPC endpoint.

If the issue persists, it's likely a temporary problem that will be resolved by the Sui team. Keep an eye on official updates for further information.

It sounds like you're experiencing performance issues with the Sui Mainnet RPC endpoint, specifically with queries like suix_queryTransactionBlocks and the FromAddress filter, as well as delayed execution of transactions with sui_client.execute_transaction.

Possible Causes

1. High Network Load or Traffic

   • If there is a sudden surge in network usage or congestion on the Sui Mainnet, it can lead to slower response times. The RPC endpoint might be under heavy load, especially during periods of increased activity (e.g., new dApp launches, large-scale events, or network upgrades).

2. Node Performance Issues

   • The underlying Sui node or cluster you're connecting to could be experiencing performance degradation. This could happen due to resource limitations (CPU, memory), or if the node is running on low-tier infrastructure.
   • Ensure you're connecting to a well-optimized node or use a dedicated RPC endpoint to avoid shared congestion.

3. API Rate Limiting

   • Sui's RPC endpoints may have rate-limiting mechanisms in place to prevent abuse or excessive load. If your queries exceed certain thresholds, you may experience delays or throttling.
   • Consider reviewing your queries and ensuring you’re not sending requests too frequently or in large batches.

4. Backlog of Transactions

   • Transaction queues or block propagation delays could cause lag when submitting transactions. If the network is processing a large volume of transactions, your transaction may take longer to be included in a block or acknowledged.

5. Temporary Outages or Maintenance

   • It’s possible that the Sui network or its infrastructure is undergoing temporary issues or maintenance, which can cause delays in response times. Check official channels (e.g., Sui’s status page or developer forums) for any known outages or ongoing updates.

6. Issues with the RPC Node Provider

   • If you’re using a third-party RPC provider, their infrastructure might be facing issues. For instance, a delay in response could be due to their server being overloaded or facing a failure.

How to Check if It's a Widespread Issue

1. Check Community Discussions

   • Visit Sui's official forums, Discord, or Twitter to see if other developers are experiencing similar issues.
   • You can also check the Sui status page for any known outages or ongoing issues.

2. Monitoring and Logs

   • If you’re managing your own node, monitor its logs and resource usage to ensure it’s not being overwhelmed.
   • For third-party services, you can contact the service provider to inquire about any known issues or maintenance.

3. Test on Different Endpoints

   • Test RPC queries on different endpoints or use different network configurations (e.g., switching between Mainnet and Testnet) to see if the problem persists.

Potential Fixes or Workarounds

1. Retry Logic: Implement retry logic in your code with exponential backoff to handle transient errors or slow responses.

2. Optimize Queries: Consider reducing the complexity of your queries. For instance, filtering by FromAddress and querying large blocks of data can be inefficient. Break down the queries into smaller, more manageable chunks.

3. Use Dedicated Nodes: If you’re using a third-party RPC provider, consider switching to a dedicated or premium endpoint to improve reliability and reduce latency.

4. Query Cache: Use a caching strategy for repeated queries to avoid unnecessary load on the RPC endpoint.

5. Contact Sui Support: If the issue persists and seems widespread, reach out to Sui’s support or community for additional assistance.

Conclusion

Performance issues like the one you’re encountering with suix_queryTransactionBlocks and sui_client.execute_transaction can occur due to network load, node performance issues, or rate-limiting. It may or may not be a temporary problem, and checking community feedback, monitoring node performance, and considering alternate endpoints can help identify and resolve the issue.

Yes, Sui Mainnet RPC delays (20s queries, 5s TXs) are likely temporary. Common causes:

1. Network congestion (high traffic).
2. RPC rate-limiting (if you’re spamming queries).
3. Upgrades/outages (check Sui Status).

Quick Fixes:

1. Retry with Exponential Backoff:

   async function executeWithRetry(tx, maxRetries = 3) {
     let delay = 1000; // 1s initial delay
     for (let i = 0; i < maxRetries; i++) {
       try {
         return await suiClient.executeTransaction(tx);
       } catch (err) {
         await new Promise(resolve => setTimeout(resolve, delay));
         delay *= 2; // Exponential backoff
       }
     }
     throw new Error("Max retries reached");
   }
   

2. Switch RPC Endpoint:

   const client = new SuiClient({ url: "https://fullnode.mainnet.sui.io:443" });
   // OR use a backup provider (e.g., Chainbase, QuickNode)
   

3. Optimize Queries:

   • Avoid FromAddress filters on large histories.
   • Use limit and cursor for pagination:

     await client.queryTransactionBlocks({
       filter: { FromAddress: "0x..." },
       limit: 10, // Fetch fewer TXs
     });
     

Yes, others are experiencing similar delays. This is likely temporary due to either network congestion or RPC node overload. Sui's team is already working on optimizations.

Immediate Workarounds:

1. Switch RPC Providers
   Try these alternatives:

   // Quick provider test
   const providers = [
     'https://sui-mainnet-endpoint.blockvision.org',
     'https://sui-mainnet.nodeinfra.com',
     'https://sui-mainnet-rpc.allthatnode.com'
   ];
   

2. Optimize Your Queries
   For suix_queryTransactionBlocks:

   // Add pagination and limit
   await client.queryTransactionBlocks({
     filter: { fromAddress: '0x...' },
     limit: 20,  // Reduce from default 50
     order: 'descending'
   });
   

3. Transaction Speed Fixes

   // Set explicit gas parameters
   await client.executeTransactionBlock({
     transactionBlock: txBytes,
     options: {
       showEffects: true,
       skipCheck: true  // For faster execution
     },
     gasBudget: 50_000_000  // Higher budget = less retries
   });
   

Yes, others are experiencing slow Sui Mainnet RPC issues. Delays in suix_queryTransactionBlocks (20s+) and execute_transaction (5s+) suggest temporary network congestion or RPC overload.

Possible Fixes:

• Try a different RPC endpoint.
• Check Sui status page/discord for outages.
• Retry later if it’s a temporary spike.

Likely not just you—wait for fixes or switch endpoints.

Yes, many users are experiencing similar issues with the Sui mainnet RPC.

Public RPCs are rate-limited and not optimized for heavy queries like suix_queryTransactionBlocks with FromAddress filters — these can take 15–30s or even time out.

sui_client.execute_transaction delays (up to 5s) are also common under load.

This isn’t a temporary outage, but rather expected behavior on the public fullnode.

To improve performance, consider using a private RPC (e.g. Ankr, Alchemy) or running your own fullnode.

If you're noticing unusually slow response times from the Sui mainnet RPC endpoint—especially with queries like suix_queryTransactionBlocks using FromAddress filters, or executeTransactionBlock taking several seconds—you're not alone. These delays can happen temporarily during high network load, indexing lag, or if your query hits older data that hasn’t been efficiently cached. Filtering by FromAddress can be expensive depending on how the RPC provider is indexing their data, which might explain the 20s+ delay.

Right now, this isn’t necessarily a bug in your app but a performance limitation with the public RPC infrastructure. For more stable and faster queries, especially in production, you should consider using a high-performance RPC provider or running your own full node with indexing enabled. If this issue just started, it could be tied to a temporary load spike or a backend update. You can track ongoing status updates and RPC reliability from Sui’s official channels at https://status.sui.io.