A user connects their Rabby Wallet to Ethereum, sees a balance of 2.5 ETH, and then switches to Arbitrum. The interface loads, but the balance shows zero. They switch back to Ethereum, and the balance reappears. They try a transaction on Polygon and receive a “failed to fetch” error. These are not database errors in the wallet itself. They are failures of the Remote Procedure Call (RPC) nodes that the wallet depends on to read blockchain state, broadcast transactions, and verify balances. Understanding why these failures occur, how they propagate through the wallet interface, and what can be done to fix them requires examining the invisible infrastructure between the application and the blockchain.
Rabby Wallet, as a non-custodial EVM wallet available across browser extension, mobile, and desktop platforms, relies on external RPC endpoints to query account balances, estimate gas fees, simulate transactions, and broadcast signed data to the network. The wallet itself does not run a blockchain node. Instead, it sends requests to third-party RPC providers and displays the results. When those providers are slow, misconfigured, or temporarily offline, the user experience degrades immediately. The wallet cannot recover passwords or reverse transactions, but it also cannot force an RPC node to respond faster. What appears to be a wallet malfunction is often a node synchronization failure, rate limiting issue, or network route degradation that sits entirely outside the wallet’s code.
How RPC endpoints become a single point of failure
When Rabby Wallet displays a balance, it is not retrieving that number from storage. It is sending an HTTP request to an RPC node, asking for the current state of a specific blockchain address. The node responds with the balance, recent transactions, and other on-chain data. If the node is slow or unreachable, the wallet waits or times out. If the node is behind the current block height, it may return stale data. If the node is configured incorrectly, it may return false information. The wallet has no way to verify which of these situations has occurred without comparing results from multiple independent sources, which most default configurations do not do.
Rabby Wallet ships with default RPC endpoints for major networks such as Ethereum, Polygon, Arbitrum, and Optimism. These endpoints are managed by Rabby or selected partners and are intended to handle most user requests. However, public RPC endpoints are not unlimited resources. They are subject to rate limits, geographic latency, and network congestion. During periods of high activity, an endpoint may begin rejecting requests from individual users to preserve capacity for others. During network upgrades or node client updates, an endpoint may temporarily fall behind, returning balances from blocks that are ten or twenty blocks old. Neither situation represents a wallet bug. Both represent the natural behavior of infrastructure that is shared across thousands of wallets and applications.
The second failure mode occurs when a user switches chains. Rabby Wallet maintains separate balance states for each supported EVM chain. When the user switches from Ethereum to Arbitrum, the wallet must fetch a new balance from the Arbitrum RPC endpoint. If that endpoint is slower than the Ethereum endpoint, the interface may appear to load but display zero while the request is still in flight. If the Arbitrum endpoint is experiencing issues, the request may time out entirely, leaving the user with an error or a blank balance. The perception is often “the wallet is broken,” but the wallet itself did nothing wrong; the Arbitrum node failed to respond within the expected window.
Custom RPC endpoints introduce a third failure mode. Users who configure their own node endpoint, whether by running a local node or by selecting a less-popular provider, may inadvertently introduce synchronization problems. A local node that is still syncing the chain will return balances from incomplete data. A custom endpoint without proper backup or failover will disappear if that provider has an outage. A node behind a geographic proxy or with unusual network configurations may respond with higher latency, causing the wallet to time out. These are user-configuration problems rather than wallet-code problems, but they manifest as balance mismatches and failed transactions.
Why balance mismatches occur between chains and accounts
A mismatch between balances shown on Ethereum and Arbitrum for the same account does not necessarily indicate that funds have moved or been lost. The two balances are stored on two separate blockchains, queried from two separate RPC endpoints, and updated at different times. If the Ethereum endpoint is faster and more responsive, the Ethereum balance will refresh more frequently and appear more current. If the Arbitrum endpoint is slower, the Arbitrum balance will lag behind the actual state. The wallet displays each balance as it receives it, without necessarily reconciling the timestamps or freshness of the underlying data.
This lag becomes more apparent during active trading or bridging. A user may bridge ETH from Ethereum to Arbitrum, see the balance decrease on Ethereum immediately, but the Arbitrum balance may not increase for several seconds or minutes. This is not a lost transaction. The bridge contract on Ethereum has received the funds, but the Arbitrum endpoint has not yet processed the corresponding mint transaction on the destination chain. Until both RPC nodes have indexed the relevant blocks, the balances appear inconsistent. The wallet cannot know how long this will take, so it continues to display whatever each node reports.
Between different accounts on the same chain, balance mismatches can indicate that one account is misconfigured or that the RPC node is returning data from different block heights. If a user imports a hardware wallet and a software wallet in Rabby, both using the same seed phrase, they should have identical balances. If they do not, the most common cause is that the RPC endpoint has served data from different block heights for the two queries. The second query may have been executed against an older state of the blockchain because the node fell behind between requests. Waiting a few seconds and refreshing usually resolves this, but it highlights the importance of consistent node state.
The deeper issue is that Rabby Wallet, like most non-custodial wallets, has no persistent storage of historical balances. It queries the current state on demand. If that state is inaccurate or inconsistent, the wallet can only display what the node reports. This is why running a personal Rabby Wallet guide or checking this guide should always emphasize verifying balances using a block explorer like Etherscan or Arbiscan, which query the chain independently and can confirm whether the RPC endpoint or the wallet is the source of discrepancy.
RPC rate limiting and how it breaks transaction submission
Public RPC endpoints enforce rate limits to prevent abuse and manage costs. A typical rate limit might allow 50 requests per second from a single IP address, or 1000 requests per hour. These limits are designed to accommodate normal usage but not to support continuous, high-frequency queries. When a user opens Rabby Wallet, it may immediately request the balance for their Ethereum account, their Arbitrum account, their Polygon account, and any other chains they have configured. If multiple dApps are also connected to Rabby and querying the same endpoints, the requests can accumulate quickly.
Once rate limits are exceeded, the RPC endpoint responds with HTTP 429 (Too Many Requests) or silently drops the request. Rabby Wallet will display an error or simply fail to load the balance. More critically, if a user is attempting to broadcast a transaction, and the RPC endpoint that handles that specific network is rate-limited, the transaction submission will fail. The user sees a message like “failed to fetch” or “network error,” but the actual problem is that the public endpoint is temporarily unavailable to that user. This is not a rejection of the transaction due to invalid parameters; it is a temporary unavailability of the service used to submit it.
The duration of rate limiting is usually short, from seconds to a few minutes. Retrying the transaction often succeeds. However, if a user has multiple wallets, multiple tabs, or multiple applications using the same public RPC endpoint, they can collectively exceed the rate limit and cause temporary unavailability for all of them. This is why experienced users often have a primary endpoint and a backup endpoint configured, and why the EVM wallet space has seen an explosion of alternative RPC services from providers such as Infura, Alchemy, Ankr, and QuickNode.
Custom node configuration and synchronization lag
Users who run local blockchain nodes and configure them as custom RPC endpoints in Rabby Wallet often encounter synchronization lag. A local Ethereum node can take many days to sync from genesis, and a node that is still syncing will return balances from incomplete data. If a user has synced through block 18 million and the network is at block 19 million, their node will report only balances and transactions that existed as of block 18 million. Any recent activity will be invisible until the node catches up.
This is particularly problematic for newly imported accounts. If a user imports a hardware wallet into Rabby and points it at a node that is behind the current block height, Rabby will show zero balance even if the address contains funds on the main chain. The wallet is working correctly; the node is simply not synchronized yet. Waiting for the node to finish syncing resolves the issue, but users often do not realize why it is happening, leading to false reports of lost funds.
State pruning and archive mode also affect which data a custom node can serve. A full node that prunes state will not have historical account balances from blocks older than the retention window. An archive node will have complete history but requires substantially more disk space. If a user configures a pruned node as their RPC endpoint, Rabby may be unable to retrieve historical transaction data or balances from more than a few days ago. This is not a wallet limitation; it is a consequence of the node’s storage configuration.
The solution is to verify that a custom RPC endpoint is fully synced before relying on it for balance queries. This can be done by comparing the highest block number reported by the custom node to the highest block number reported by a public node or a block explorer. If the numbers differ, the custom node is behind and should not be trusted for current balance information. For users who require very reliable access, running multiple redundant nodes or using a managed node service with automatic failover is more practical than relying on a single local instance.
Diagnosing failed transactions and pending states
When a user broadcasts a transaction through Rabby Wallet, they are sending a digitally signed message to an RPC endpoint, which then propagates it to the blockchain network. If the RPC endpoint receives the transaction, it will be added to the mempool and eventually included in a block. If the RPC endpoint is unreachable or rate-limited, the broadcast fails immediately. But if the broadcast succeeds and the RPC endpoint is temporarily behind, the wallet may show the transaction as pending even after it has been included in a block.
This creates a confusing situation: the user believes their transaction is still processing, but the blockchain has actually finalized it. They may see a “pending” badge in Rabby’s transaction list, while a block explorer shows the transaction as confirmed. This discrepancy resolves once the RPC endpoint has synced to the block containing the transaction, but it can last for minutes or longer on slower networks.
The opposite failure occurs when a transaction is rejected by the network but the RPC endpoint does not properly communicate that rejection. The user may see “broadcasting” or “pending” for an extended period, with no clear error message. In this case, the transaction was never included because it violated a network rule (insufficient gas, incorrect nonce, bad signature) but the RPC endpoint did not validate these before attempting broadcast. Checking the transaction hash on a block explorer will confirm whether it exists; if it does not, the broadcast failed at the RPC endpoint level.
To diagnose these issues, users should always verify transaction status through a block explorer independently. Etherscan, Arbiscan, Polygonscan, and other chain-specific explorers query the blockchain directly and bypass the wallet and its RPC endpoints entirely. If a transaction shows as confirmed on the explorer but pending in Rabby, the wallet’s RPC endpoint is simply behind. If it shows as not found on the explorer, the broadcast either failed or the transaction was never submitted to the network.
Selecting reliable RPC endpoints and setting up redundancy
The default public RPC endpoints provided by Rabby Wallet are generally reliable, but they are not guaranteed. Rabby has no control over occasional outages or degraded performance from these endpoints, and users should not assume that a balance query or transaction broadcast will always succeed on the first attempt. For critical operations, users should configure multiple RPC endpoints for each chain and enable endpoint rotation or failover.
Managed RPC services such as Infura, Alchemy, Ankr, and QuickNode offer higher reliability and more sophisticated monitoring, though they typically require creating an account and obtaining an API key. These services distribute requests across multiple nodes, implement automatic failover, and provide better latency through geographic distribution. They are not free, but for users managing significant assets or requiring frequent transactions, the cost is justified by the reduction in failed transactions and balance mismatches.
For users who prefer to run their own infrastructure, the alternative is to operate multiple redundant nodes and configure Rabby to query them in sequence. This requires significantly more technical overhead and careful synchronization management, but it eliminates reliance on third-party services. The trade-off is between convenience and centralization: managed services are easier to use but introduce a commercial entity into the transaction path, while local nodes are harder to operate but give the user complete control.
The practical recommendation for most users is to use Rabby Wallet’s default endpoints for routine queries and balance checks, but when broadcasting a high-value transaction or dealing with a problematic network, temporarily switch to a paid, managed endpoint or verify the transaction status on a block explorer before assuming it has failed. This hybrid approach minimizes cost and complexity while reducing the risk of failed transactions due to endpoint unavailability.
Network selection mistakes and how they look like sync failures
One of the most common causes of apparent balance mismatches is selecting the wrong network entirely. Rabby Wallet supports dozens of EVM-compatible chains, and it is easy to accidentally configure an account for the wrong chain or to send a transaction to an unintended destination. An account on the Ethereum Sepolia testnet will appear to have zero balance when the user switches to Ethereum mainnet, but not because funds have disappeared; they were never on mainnet to begin with.
Similarly, a user might bridge tokens to a secondary chain, forget which chain they are on, and conclude that the tokens are lost when the wallet shows zero balance on their previous network. The tokens were successfully moved; the user simply needs to switch to the destination chain to see them. This is a user-interface problem more than a node problem, but it often leads users to believe that their wallet is broken or that an RPC endpoint has failed.
To avoid these mistakes, users should always verify the network name and chain ID in the wallet settings before broadcasting a transaction, especially if they are interacting with bridges or cross-chain protocols. Rabby Wallet displays the current network prominently, but it is easy to overlook during rapid interaction with dApps. Slowing down and double-checking the network selection before signing prevents the most common category of user-perceived sync errors.
Recovery strategies when sync problems persist
If balance mismatches or failed transactions persist despite waiting and retrying, the first step is to verify the actual blockchain state using a block explorer. This answers the fundamental question: are the funds actually on the blockchain, and has the transaction actually been submitted? If the block explorer shows the balance correctly and the transaction exists, the problem is entirely on the wallet-to-node side, and the solution is to switch RPC endpoints.
Switching endpoints can be done by selecting a different network from Rabby’s settings menu or by adding a custom RPC endpoint. If the default endpoint for Ethereum has been unreliable, trying the next available endpoint or adding a custom endpoint from a managed service like Alchemy often resolves the issue immediately. The transaction data does not change; only the route used to query and interact with the blockchain changes.
For users experiencing chronic sync issues with local nodes, the most practical solution is to abandon the local node and use a managed service instead. Running a reliable, synchronized node is a technical undertaking that requires proper hardware, network connectivity, and maintenance. For most users, the cost of a managed RPC service is lower than the cost of troubleshooting and maintaining a local node.
If transactions remain stuck in pending state after hours, the final recovery option is to check the transaction’s nonce and gas price on a block explorer, then use Rabby’s transaction management tools or a more advanced wallet to replace or cancel the stuck transaction. This requires understanding transaction nonces and is not a typical user operation, but it can rescue funds from a transaction that will never be included due to insufficient gas or network congestion.
Frequently asked questions
Why does my Rabby Wallet balance show zero on one chain but appears correct on another?
This typically indicates that the RPC endpoint for one chain is either unreachable, rate-limited, or behind the current block height. Try refreshing the page, switching chains and switching back, or manually selecting a different RPC endpoint from the network settings. If one network consistently fails, add a custom RPC endpoint from a service like Alchemy or Infura for that specific chain.
My transaction shows pending in Rabby but does not appear on the block explorer. What happened?
The transaction either failed to broadcast to the network or was rejected by the RPC endpoint before submission. Check the transaction hash on the block explorer; if it does not exist, the broadcast failed. Try broadcasting again from Rabby, or switch to a different RPC endpoint. If the transaction does exist on the explorer, your wallet’s RPC endpoint is simply behind and will show the correct status once it syncs.
Can I improve RPC reliability by running my own local node with Rabby Wallet?
Yes, but only if the node is fully synced and properly configured. A node that is still syncing will return incomplete or incorrect balance data. A pruned node cannot serve historical data. For most users, using a managed RPC service is more practical than maintaining a local node, as it requires less hardware and technical expertise while providing better uptime and geographic distribution.