A user opens Phantom Wallet on their phone after a transaction, and the token balance shows one amount. They switch to Etherscan or another block explorer and see a different figure. The transaction appears confirmed on-chain, but Phantom still shows the old balance. This discrepancy is not a bug in the wallet itself—it is a real consequence of how blockchain nodes communicate, how state is finalized across networks, and how wallet software queries that state. Understanding the difference separates a genuine problem from a timing issue that resolves within seconds or minutes.
Phantom Wallet serves multiple blockchains including Solana, Ethereum, Bitcoin, and others, and each one has its own rules for how quickly state becomes observable and how wallet clients learn about updates. When balances disagree, the root cause is almost always an RPC (Remote Procedure Call) node lag or a difference in how the wallet and the block explorer query and cache blockchain state. Knowing what is happening behind the display screen helps users distinguish between phantom not working and phantom not synced, and when to refresh versus when to wait.

RPC nodes are not the blockchain—they are a copy asking for updates
A blockchain explorer like Etherscan connects to one or more Ethereum nodes that maintain a full or partial copy of the ledger. Similarly, Phantom Wallet connects to RPC endpoints—servers operated by Phantom, infura, quicknode, or other providers—to retrieve account balances, transaction status, and other data. Neither the wallet nor the explorer directly asks the blockchain itself; both ask a node, and that node may be behind the current state by seconds, minutes, or longer depending on network congestion and node performance.
The Ethereum Foundation publishes technical documentation outlining how nodes participate in consensus and maintain state, but wallet software must operate within practical constraints. When a user initiates a transfer and signs a transaction, the wallet broadcasts it to the network. The transaction enters a mempool—a waiting area on nodes where unconfirmed transactions gather. Once a validator or miner includes the transaction in a block, it is added to the canonical chain. At that moment, the balance should change. But the RPC node that Phantom queries may not have processed that block yet, or it may have processed it with a slight delay.
This lag is not uniform. Some RPC providers maintain faster infrastructure than others. During times of high network activity, nodes can fall further behind. If Phantom is using a slower RPC endpoint, or if the endpoint is experiencing temporary congestion, the balance shown in the wallet may lag behind what is already recorded on-chain. The block explorer may use a different RPC provider or a more direct connection to network data, making it appear to show a “more current” balance even though both are technically correct snapshots from different moments in time.
According to Ethereum Foundation technical documentation, clients synchronize state through block headers and state roots, and the propagation of that information across the network depends on peer connectivity and processing capacity. A wallet cannot display a balance it has not yet learned about. If the RPC node has not informed the wallet about a recent block, the wallet is not failing—it is simply reporting what it knows.
Solana, Ethereum, and Bitcoin finalize state differently
Finality—the point at which a transaction cannot be reversed—operates on different timescales across blockchains. Solana’s architecture uses a proof-of-history consensus mechanism where validators confirm transactions and create sequential records. Under normal conditions, transactions reach finality within seconds. Ethereum, by contrast, uses a two-stage process: after The Merge, blocks are proposed and attested by validators, with economic finality typically established after about two epochs (roughly 13 minutes). Bitcoin does not have a formal finality boundary; transactions are considered increasingly final as more blocks are added on top of them, with a common rule-of-thumb being six confirmations for certainty.
Phantom Wallet must account for these differences when displaying balances. On Solana, a token balance change can reflect in the wallet very quickly. On Ethereum, the wallet may distinguish between a transaction that is “pending confirmation,” “tentatively confirmed,” or “finalized.” During this window, the balance reported by Phantom might differ from what Etherscan shows if the two services are querying different nodes or looking at different confirmation stages. Some block explorers also apply additional data sources or cache old information, potentially displaying a balance that appears different from the live chain state.
The user experience consequence is that Phantom, like any non-custodial wallet, can only report what its connected RPC nodes tell it. If a transaction fails silently at the mempool stage—rejected because the gas price was too low, the nonce was incorrect, or another validation rule was violated—neither the wallet nor the explorer immediately shows the failure. Instead, the transaction may appear stuck. The actual error may only be visible if the user checks the node’s logs, queries the RPC endpoint directly, or waits long enough for the transaction to time out and disappear from the mempool.
Why phantom not working often means phantom not refreshed
When a user reports that phantom not working because a balance is incorrect, the most common resolution is to refresh the wallet. Phantom includes a refresh mechanism that forces the wallet to re-query its RPC endpoints and fetch the latest state. On mobile, this is typically a pull-to-refresh gesture. On browser extensions, a manual refresh of the extension or wallet interface forces a new RPC call. That action clears any stale cached balance and retrieves the current balance from the node.
The reason a manual refresh is necessary illustrates an important design trade-off. Constantly querying the RPC for every possible change would drain battery on mobile and create excessive network traffic. Instead, wallets poll the RPC at intervals—often every few seconds to a minute—or listen for specific events. If the wallet’s last poll happened just before a block containing the user’s transaction was finalized, the wallet will not know about the balance change until the next poll. A manual refresh bypasses the wait by immediately issuing a new RPC call.
Browser extension wallets face an additional wrinkle: the extension may suspend or reduce its background activity when the browser tab is inactive. If a user has Phantom open in one tab, switches to another tab for several minutes, and returns, the wallet may not have polled the RPC during the inactive period. The balance shown might represent the state from the moment the tab was left. Refreshing retrieves the current state, assuming the RPC has caught up in the meantime.
The distinction between a wallet not working and a wallet not refreshed also matters when troubleshooting. If a manual refresh resolves the issue, the problem was RPC lag or cache staleness, not a fundamental wallet failure. If a refresh does not change the balance, and the transaction is confirmed on a block explorer using a different RPC provider, the user’s RPC endpoint may be persistently lagging or offline. In that case, Phantom may offer the ability to switch to a different RPC provider or use a fallback, depending on the wallet’s settings.
Block explorers have their own caches and data sources
Etherscan, Solscan, and other block explorers maintain their own infrastructure separate from wallet providers. When a user checks a transaction or balance on Etherscan, they are querying Etherscan’s nodes and databases, not the blockchain directly. Etherscan also indexes and caches historical data, applies custom queries, and may include additional data sources like token metadata services. This means Etherscan can sometimes display information faster or differently than a wallet using a standard RPC connection.
For example, Etherscan shows a transaction as “confirmed” after it has been indexed into their database. A wallet using an RPC endpoint may not have that same transaction in memory yet. Conversely, if the explorer’s node has fallen behind, the explorer may show an older balance than what is actually on-chain. The user sees both interfaces and naturally assumes the one showing the more favorable or most recent data is correct. In reality, both are correct snapshots from different times or different slices of the network.
This is why blockchain explorers are useful for verification but not authoritative. They are tools for transparency, not truth oracles. If Phantom and Etherscan disagree, the user should check both the latest block on the chain and verify which RPC endpoint or explorer is actually more current. Multi-chain wallets like Phantom that support Ethereum, Solana, Bitcoin, and others must manage these discrepancies across each blockchain’s unique architecture and RPC landscape.
Hardware wallet integration and RPC lag
Phantom supports hardware wallets such as Ledger, allowing users to sign transactions while keeping their private keys on a separate device. Ledger’s hardware wallet documentation describes the signing and derivation process that Phantom uses to coordinate with the physical device. Even when using a hardware wallet, Phantom still connects to RPC nodes to fetch balance and transaction data. The difference is that the wallet cannot modify those balances or initiate transactions without the user physically confirming on the Ledger device.
This separation creates an interesting edge case. A user can have two instances of Phantom—or Phantom plus another wallet—accessing the same hardware device through different RPC endpoints. If one instance refreshes and shows an updated balance before another, the discrepancy is purely because they are connected to different RPC nodes at different states. The hardware wallet itself has no balance; it is merely a key manager. The balance lives on-chain, and the wallet’s display is always a query result, never ground truth.
When phantom transaction failed messages appear, they are usually RPC-level failures: the transaction was rejected before it reached the network, or it was accepted into the mempool but not included in a block (either due to low gas price, mempool eviction, or other reasons). Hardware wallet integration does not change this; it only adds a signing step before the RPC step. If the RPC endpoint is slow or offline, a hardware-backed transaction will fail in the same way that a software-backed one would.
Refreshing state and forcing RPC synchronization
Phantom Wallet provides multiple ways to ensure the latest state is displayed. The simplest is the manual refresh: on mobile, a pull-to-refresh swipe; on browser extension, a refresh icon or keyboard shortcut. This immediately sends a new RPC request and overwrites the cached balance with whatever the node reports. If the node has processed the latest blocks, the balance updates. If the node is still lagging, refreshing may not help immediately, but repeating the refresh after a few seconds often does as the node catches up.
Another approach is to disconnect and reconnect the RPC endpoint. Some wallet providers, including phantom wallet, allow users to manually select or switch RPC endpoints in settings. Disconnecting from one RPC endpoint and connecting to another forces the wallet to query a potentially faster or more current provider. This is particularly useful if the user suspects their primary RPC endpoint is lagging or offline.
For transactions that appear stuck, the situation is more nuanced. If phantom transaction failed indicates that the transaction was not accepted into the mempool, retrying with a higher gas price or corrected parameters may succeed. If the transaction entered the mempool but has not been included in a block, waiting longer is often necessary. Some RPC endpoints provide transaction receipt endpoints that return historical records; querying these directly (through web3 tools or a block explorer API) can reveal whether the transaction was actually committed even if the wallet has not yet displayed the update.
Users should avoid repeatedly re-sending the same transaction without modifying its parameters. If the first attempt entered the mempool, re-sending creates a duplicate that competes for inclusion. Broadcasting multiple identical or near-identical transactions with different nonces can create a congestion issue in the wallet’s pending transaction queue. Instead, wait for the first attempt to time out or be explicitly confirmed before proceeding.
Practical steps when balances disagree between wallet and explorer
When Phantom shows a different balance than Etherscan or another block explorer, here is a reliable diagnostic sequence. First, manually refresh Phantom by pulling to refresh (mobile) or clicking the refresh control (browser extension). Wait a few seconds and refresh again. This often resolves the discrepancy as the RPC endpoint catches up with the latest blocks. Second, cross-check the specific transaction on the block explorer by searching for the wallet’s public address or the transaction hash. Confirm that the transaction is actually confirmed on-chain and not still pending or failed.
Third, verify which RPC endpoint Phantom is using. In the wallet settings, check for a custom RPC option or a provider selection menu. If a custom or low-performance RPC is selected, try switching to a default or different provider. Fourth, check whether the balance difference is actually meaningful. A difference of a few wei (smallest Ethereum units) or a satoshi (smallest Bitcoin unit) due to precision rounding is normal. A significant difference usually indicates either incomplete synchronization or a confusion between different asset types (for example, a token balance versus native ETH balance).
Fifth, if the transaction is confirmed on the explorer but Phantom refuses to update, try clearing the wallet’s cache (if that option exists in settings) or, as a last resort, re-importing the wallet without deleting the extension or app. This forces the wallet to re-initialize and re-query all state from scratch. Recovery phrases remain valid; re-importing restores access to the same assets without any loss. Do not delete the extension or app without first ensuring the recovery phrase is safely backed up.
Multi-chain complexity and state consistency
Phantom supports Solana, Ethereum, Base, Polygon, Bitcoin, and other chains. Each has its own RPC endpoints, its own finality model, and its own timing characteristics. A user with balances on multiple chains may experience different sync speeds on each. A balance on Solana might update quickly, while the Ethereum balance lags. This is not an inconsistency in Phantom—it is a reflection of how each blockchain’s network infrastructure and RPC landscape operates.
When moving funds between chains through Phantom’s built-in bridge functionality, the state change occurs at different times on the source and destination networks. The bridge initiates a transaction on the source chain, which after finality triggers a transaction on the destination chain. During the interim period, the balance on the destination wallet may not reflect the incoming transfer. Refreshing prematurely does not help; the funds simply are not on the destination chain yet. The bridge status or transaction details in Phantom usually indicate the expected arrival time or current stage.
For users staking SOL through Phantom (with a 1 SOL minimum), balance display is further complicated by the fact that staked SOL and liquid staked SOL (PSOL) are separate token types with separate balances. The wallet correctly displays both, but if the user is expecting a combined view, the separation might seem like a discrepancy. Refreshing does not change this; it is part of how Solana’s staking and token system works.
Caching, polling intervals, and the limits of real-time wallet displays
No wallet can be truly real-time unless it maintains an active subscription to every block or event stream from an RPC endpoint. Most wallets, including Phantom, use a polling model where they query the RPC at regular intervals (typically every few seconds to a minute) and cache the result. This reduces network load and battery drain but means there is always a small window between when state changes on-chain and when the wallet learns about it.
During times of extreme network congestion, polling intervals may extend further because the RPC endpoint itself may be slow to respond. The wallet’s design attempts to balance responsiveness with resource consumption. Too-frequent polling drains the device and creates excessive RPC traffic; too-infrequent polling leaves users waiting for updates that are minutes old.
Users should understand this trade-off and not interpret a delay of a few seconds to a minute as a wallet malfunction. If a transaction is confirmed on-chain (which can be verified on a block explorer), and Phantom has not yet reflected it, waiting and refreshing is the appropriate response. If hours pass without an update despite repeated refreshes, the problem is either a persistent RPC issue, a genuine wallet bug (rare but possible), or a misunderstanding about which blockchain or token balance should have changed.
Frequently asked questions
Why does Phantom Wallet show a different balance than Etherscan?
Phantom and Etherscan query different RPC nodes or nodes at different stages of synchronization. Phantom shows what its RPC endpoint has learned; Etherscan shows what its own infrastructure has indexed. Both are correct snapshots from different times. Manually refreshing Phantom forces it to query its RPC endpoint again, which usually resolves the discrepancy once the node has caught up with the latest blocks.
What does it mean when phantom not working shows a zero or old balance?
The most common cause is that the wallet’s cached balance is stale and has not been refreshed. Pull to refresh on mobile or click the refresh icon on browser extension. If a refresh does not help, try switching to a different RPC endpoint in the wallet’s settings, or verify on a block explorer that the transaction is actually confirmed on-chain. RPC lag or endpoint issues are the typical culprits, not wallet malfunctions.
What should I do when phantom transaction failed appears on my transaction?
Check the transaction details or search the transaction hash on a block explorer to see if it was actually committed to the blockchain. If it was rejected before reaching the mempool, the issue is usually insufficient gas, incorrect nonce, or invalid recipient address. If it entered the mempool but was not included in a block, retry with a higher gas price. Avoid repeatedly sending the same transaction; wait for the first one to time out or succeed before sending another.
Does using phantom wallet with a hardware wallet like Ledger eliminate RPC lag?
No. A hardware wallet handles signing and key management, but Phantom still connects to RPC endpoints to fetch balances and transaction data. Hardware integration does not change how the wallet learns about on-chain state changes. Balance updates are still subject to RPC lag, and refreshing works the same way whether or not a hardware wallet is connected.