Anza gave Solana node operators until epoch 1079 to install a patch that changes how the network counts the account data a transaction loads. A machine running an older build could stay online and still fall out of step with the accepted chain, with different consequences for validators earning staking rewards and services that wallets rely on for current data.
Summary
- Anza asked staked and unstaked mainnet nodes to run Agave 4.4.1 or Firedancer 26.10.6 before epoch 1079, which it estimated would begin at around 13:30 UTC on 6 November.
- The patch set a minimum size for loader-v3 ProgramData accounts when the runtime counts loaded data. A transaction already near the data limit could produce a different result under the two rules.
- The software release and the feature gate are separate milestones. Operators can deploy compatible code before the chain begins applying it at the scheduled epoch.
- A validator that falls out of step can stop recording effective votes, which can reduce rewards for stake delegated to it. The vote and reward records would establish the effect on an individual operator.
- The same patch applied to unstaked infrastructure. An outdated RPC endpoint or an exchange deposit delay can affect users even if the chain continues to produce blocks.
Anza warned validators before epoch 1079 that operators running older software risked being left behind when the network switched on a new rule. The compatible versions cited were Agave 4.4.1 and Firedancer v26.10.6.
The Agave feature-gate tracker identifies the relevant change as a minimum loaded data size for loader-v3 ProgramData accounts. Its version-floor table separates the releases used by test networks from those planned for mainnet. Reading the schedule requires checking the cluster, the feature and the epoch together.
The deadline also covered nodes that do not vote. Those machines can supply wallets and exchanges with balances, blockhashes and confirmation data. A problem at one of them can reach users who never delegated SOL or chose a validator.
What the change does
A Solana programme can use an account to hold its executable data. When a transaction needs to load a programme, the network accounts for data associated with that operation. A minimum applied to a programme-data account changes how compatible software treats the relevant transaction under the new rule.
The purpose of a feature gate is to coordinate when participants begin using a new rule. Operators can install a release ahead of time, while the actual rule change takes effect at an agreed point. A version can therefore support a feature before that feature is active on mainnet.
Once the gate activates, an older release may disagree with the upgraded software about a transaction or the state produced by a block. A validator can then stop following the chain recognised by the rest of the network even though the server itself remains online. That is the practical meaning of Anza’s warning about being forked off.
Why the stake behind the nodes matters
A hundred small validators and a handful of large operators need not represent comparable amounts of voting stake. For the network’s operation, the relevant question is how much stake follows the compatible rules. The tracker says minor-version mainnet floor changes normally follow a stake-adoption threshold and a waiting period. That general rule should be kept distinct from the specific warning issued ahead of epoch 1079.
An adoption check should pair version information with active stake, then compare those figures with voting participation after the boundary. A node reporting the right release may still be catching up or experiencing a separate fault. Conversely, a stable aggregate can mask problems at a smaller operator if most stake remains online and votes normally.
That difference matters to delegators. Their experience depends on the validator to which their stake was assigned, rather than whether a majority of machines installed the release. If a validator stops voting effectively, the missed participation can reduce the rewards attributable to that stake. The relevant evidence would be vote credits and reward records for the affected epochs.
What users and exchanges would notice
A user sending SOL cares whether the transfer is accepted and reaches the intended level of confirmation. That can be checked through the transaction and network data. A claim that several operators missed an update does not by itself establish slower confirmations, a halt or a widespread outage.
An exchange can also pause deposits or withdrawals while monitoring an upgrade, even when transfers continue onchain. Its customer balances depend on its own infrastructure and crediting policies. A transaction that appears onchain can therefore remain pending in a customer’s exchange account until that venue resumes normal processing.
The useful post-upgrade comparison would check three things separately. First, did blocks continue to be produced and confirmed? Second, did the amount of stake voting effectively change? Third, did any named exchange pause or resume transfers around the boundary? Each answer needs a different record.
Why the upgrade deadline applied to infrastructure too
Anza’s Agave release notes identify the ProgramData accounting change as a backport. The Firedancer release includes support for the same feature. When two clients process the same transaction after activation, they have to agree on how much account data it loads. The shared rule is what matters at the boundary.
An unstaked RPC node can serve an application without contributing stake to votes. That makes it easy for a wallet user to encounter a local problem even if the voting validators keep producing blocks. An application reading from a lagging endpoint can display old state or return an error. Comparing its response with the same request through another endpoint helps identify where the disruption occurred.
Solana’s October Alpenglow migration offers context for how operators prepare for a coordinated change. That migration concerned the consensus protocol. November’s patch concerned account loading. Both give operators a version to verify, but the effects must be evaluated against the specific rule that changed.
What made the deadline different from a release date
Anza published Agave 4.4.1 on 5 November. Its subsequent warning to operators said the change was planned for epoch 1079, estimated to begin at around 13:30 UTC on 6 November. The version identified the software operators needed, while the epoch identified when the network planned to begin applying the rule.
An epoch boundary depends on the progress of the chain. The time in the warning gave operators a practical estimate, but the chain’s transition to the new epoch was the important event. Operators could not treat a later local time or a routine maintenance window as an extension of the schedule.
A release can include code that does not yet change how the network processes transactions. Operators install the software first, then the network activates the feature at the planned point. That sequence lets operators prepare without nodes immediately applying different rules to the same block.
The window was short even for operators who had already moved to Agave 4.4.0. The patch number changed by one, but the earlier release lacked the support needed for the new rule. A recent installation was therefore no substitute for checking the exact build.
The Firedancer 26.10.6 release supported the same feature. Operators could use different client implementations, but both needed to count the same account data when executing a transaction under the active rules.
The distinction between software and activation had already appeared in crypto.news coverage of Alpenglow’s testnet rollout. Alpenglow changed consensus, while the November patch concerned transaction processing. In both cases, a build being available was a separate milestone from the network requiring its behaviour.
Where ProgramData enters the transaction
A transaction lists accounts its instructions need. A validator loads the data associated with those accounts to carry out the instructions. The network limits how much account data a transaction can load, giving validators a bound on a category of work they perform before or during execution.
Solana’s upgradeable loader uses a program account and a separate ProgramData account. The latter stores the executable program data and associated information for the loader. A user invokes the program without manually accounting for the size of that executable data. The validator’s runtime handles that part.
The patch sets a floor for the amount attributed to a loader-v3 ProgramData account when it is loaded. If the old accounting attributed less than the floor, the new rule counts at least the minimum against the transaction’s loaded data limit. A transaction well below the limit can produce the same result after the change.
The difference matters at the boundary. A transaction that combines several instructions or uses several programs may already load substantial account data. If the new minimum puts the combined amount above the limit, the old and new rules can produce different results even with the same instructions and the same signer.
The loaded data limit is distinct from the compute budget. Compute measures execution work. A transaction can have sufficient compute to execute the instructions and still fail a limit that governs which accounts it can load. Raising the compute allowance alone does not change the amount counted against the loaded data limit.
The rule also leaves an application’s deployed instructions in place. The program can sit at the same address and have the same code while the validator charges its ProgramData account differently. Application teams have a reason to recheck transactions near the limit even if they made no deployment of their own.
How two nodes can disagree about the same block
Validators execute transactions to check the state produced by a block. If two nodes start from the same state and apply different rules to one of those transactions, they can reach different results. They cannot both treat the same resulting state as valid unless the difference is resolved.
That explains Anza’s warning about older nodes falling out of step. An old node can remain online and continue answering requests while failing to track the chain accepted by compatible validators. Its process being up is a weaker test than whether it is current and agreeing with the cluster.
An operator can compare the slot the node reports with an independent reference. A voting validator also has to check that its votes are counted on the accepted chain. Error logs may identify a problem while replaying blocks that would be invisible in an uptime check.
The warning described the consequence of incompatibility. An assessment after the deadline still needs to show which operators were running outdated builds and what happened to their nodes. A version snapshot collected after an operator recovered could miss a brief period when that validator was out of step.
The date of activation and the point at which an observer notices a problem can also differ. A narrow rule only affects transactions that exercise it. A period with no visible divergence immediately after the boundary would not show whether a node could handle a transaction near the affected limit.
Why a validator count tells only part of the story
The importance of a voting validator depends in part on how much stake it represents. A handful of large operators can represent more voting weight than many smaller ones. A count of affected machines therefore answers a different question from the percentage of active stake that continued participating.
Unstaked nodes have a separate role. They can supply applications, exchanges and wallets with data or relay signed transactions. An outage at a popular service can affect many users even though the service contributes no stake to consensus.
The relevant measures can move independently. Block production can continue while a particular RPC provider serves stale data. A validator can miss votes while its public-facing website remains available. An exchange can pause Solana deposits while the chain continues confirming transfers.
Earlier coverage of Solana’s Alpenglow deadline described a handoff requiring coordinated preparation by validators and applications. The goal there was faster finality. The ProgramData gate has a narrower technical effect, but operators still have to judge readiness against their own place in the network.
What delegators can establish from vote and reward records
Delegators have an economic question even when the network stays available. They want to know whether the validator earning rewards on their behalf continued to participate. A missed patch does not by itself move delegated SOL out of the stake account, but an interruption in voting can reduce the rewards earned during the relevant period.
The first place to look is the validator’s vote account. Comparing vote credits over the epochs around the boundary can establish whether its participation changed. Reward records give a separate check on the effect for particular stake accounts.
A lower reward does not by itself identify the upgrade as the cause. Commission, the validator’s prior performance and the stake account’s status can all affect the amount recorded. Evidence that votes stopped at the boundary and resumed after a client change would give a stronger explanation than a single lower reward.
A liquid staking token adds another layer. A pool can spread its stake across several validators. A problem at one operator may contribute only part of the change in the pool’s rewards, depending on its share of the delegation and the pool’s accounting.
Exchange staking adds a service relationship. The exchange may operate its own validators or use another provider, then credit customers according to its terms. A user would need the exchange’s records to connect an onchain change in votes with the reward credited to an individual account.
What a stale RPC endpoint can do to a wallet
Many wallets get balances, blockhashes and transaction results through an RPC endpoint. A node that falls behind may report a prior balance or fail to return a recent transaction. Users can encounter those symptoms even if other nodes are processing the network normally.
A blockhash can affect the transaction before the network executes it. A wallet that gets an outdated blockhash may construct a transaction that is no longer valid by the time it reaches a healthy node. The symptom is a failed submission, but the reason can be stale information rather than a change to the balance or the instructions.
Simulation depends on the same relationship. A node running old rules can report that a transaction fits the loaded data limit even though the nodes enforcing the new rule reach a different result. A simulation on a compatible node can still differ from the final execution if the state changes between the simulation and inclusion.
Applications with several nodes behind a single endpoint face another possibility. Requests may succeed or fail depending on which machine receives them. A provider has to check that the whole pool is current before attributing an intermittent problem to the chain.
A comparison between independent endpoints helps separate those issues. If several current endpoints agree and one service differs, the discrepancy can be local to that service. If independent observers also report a change in block production or confirmations, there is stronger evidence of a network issue.
The October consensus transition had its own infrastructure changes. Crypto.news reported that Alpenglow removed the previous onchain voting transactions. Application teams had to distinguish the change in what they observed from whether validators could follow the new system. November’s account loading rule again makes the answer depend on the observer’s role.
Why exchange credit can lag behind the chain
An exchange can credit a deposit only after its systems recognise the transfer and apply its confirmation policy. A successful onchain transaction therefore does not determine when a customer’s internal exchange balance changes.
A venue may pause deposits or withdrawals while updating infrastructure. It may also continue to receive transfers onchain while its deposit queue waits for confirmation from a healthy node. A venue notice and a block explorer can both be accurate even if one shows a service interruption and the other shows a successful transfer.
For withdrawals, a delay can occur before the exchange signs or broadcasts the transaction. The absence of an onchain record during that time says little about whether the network would accept the transaction once submitted. The venue’s processing status addresses that part of the timeline.
A report that several exchanges paused operations would still need to identify which services were affected and what reason each gave. A routine maintenance notice or a queue caused by another issue can fall in the same window as an upgrade. The coincidence is a reason to compare records, not a measure of network participation.
What would show whether operators missed the patch
The Anza feature gate tracker separates the minimum release floor from individual activations. Earlier crypto.news reporting on the Alpenglow rollout and the mainnet floor described the same distinction. A build can meet the floor at one point and lack a change scheduled for a later epoch.
The most useful post-activation record would compare the active feature, software distribution and operator participation over the same window. The feature record identifies when the rule started to apply. The software record identifies which builds were in service. Votes and blocks show whether the network and individual operators behaved differently.
Skipped slots are one possible observation. They can also increase for reasons unrelated to the patch, including the ordinary performance of the validators assigned to lead. Comparing several windows and matching skips to their leaders gives the observation context.
Delinquent stake provides a different view. The amount can move when one large validator stops participating, even if the total number of delinquent nodes barely changes. The comparison needs to account for operators that were already delinquent before the upgrade.
RPC and exchange effects have to be documented separately. Those providers can serve large numbers of users without appearing in the stake comparison. Their notices, service metrics and records of when nodes returned to current slots would describe disruptions the voting data cannot capture.
Why a staged rollout still needs an activation test
A stable client release can be deployed gradually before a new feature is active. That lets operators see whether the software starts correctly, catches up and processes transactions under the current rules. It also helps reveal deployment problems before more nodes use it.
A successful rollout before activation cannot exercise every consequence of the active feature. A transaction near the loaded account data limit needs to be tested under both rule sets to show exactly where the result changes. That is a different test from watching whether the binary remains online.
Crypto.news previously reported that Alpenglow targeted a different approach to finality. Its success criteria included what happened to confirmation speed. The ProgramData patch is better judged by whether clients agree on transactions that encounter the new limit and whether infrastructure remains available after the gate turns on.
A rollback also changes meaning at activation. Before the boundary, an older supported release may still process the rules already in force. After it, returning to a build that lacks the feature can bring back the exact incompatibility the operator was trying to resolve. A fallback has to retain support for the active gate.
An operator with spare capacity can bring a patched node up and validate it before assigning traffic. A smaller operator may have to restart its only node and wait for it to catch up. The deadline is shared, but the time users spend waiting can depend on the provider’s redundancy.
Why SOL’s price cannot measure the upgrade’s effect
SOL can fall or rise in the same hours that operators install a patch. It trades against many of the same currencies and pools of capital as other crypto assets. Rates, movements in Bitcoin and changes in leverage can affect the price during the same window.
A technical problem can matter to trading if it interrupts transfers or makes an application unavailable. Evidence for that explanation would include notices from venues, changes in deposits or withdrawals, or onchain execution data linked to the relevant accounts. A token price alone does not identify that channel.
An individual transaction failure is also distinct from loss of control over an account. A wallet may have built a transaction with old information or submitted it through a stale node. The user can still control the account while the application has trouble reaching the current network.
The most direct test after the deadline is therefore at the level of the service. A voting node should be current and recording votes. An RPC service should be answering requests from the accepted chain. An exchange should be able to account for whether and when it processed transfers submitted around the switch.
That evidence can support an assessment even if the price moves for unrelated reasons. It also gives delegators a way to evaluate the performance of their own validator without treating a network-wide version requirement as a statement about every operator’s results.
What happens when an operator comes back online
Installing the patched software is one step in restoring a node. The operator then needs to see whether the process catches up to the accepted chain and follows it under the current rules. A server can restart successfully while it is still replaying blocks or returning data that lag behind the tip.
A voting node also needs to show that its participation has resumed. Its operator can compare current votes with the time at which the node recovered. A delegator reading reward data later can then distinguish the recovery point from the time at which the patch was installed.
A service provider can take a patched node out of rotation until it has caught up and passed checks. The operator may compare the slot, the result of a recent transaction and the outcome of a simulation with a separate reference. A provider that returns the node to traffic before these checks can make a software upgrade look complete while customers still encounter old data.
The timeline matters when assessing the impact. A node that diverged and returned within the same epoch may appear healthy in a later directory. Its missed participation can still matter for the operator or delegators. A public incident timeline would need enough detail to show when service stopped and when normal activity resumed.
Application teams can also examine transactions that failed only through a particular backend. If resubmitting through a current node resolves the problem with no change to the instructions, the earlier endpoint becomes a likely source of the failure. If the same transaction consistently fails across current nodes near the account data limit, the transaction itself may need to be rebuilt.
Such a rebuild can involve reducing the data loaded by the transaction or separating instructions where the application can tolerate multiple transactions. Splitting a transaction can change its guarantees, because instructions that were meant to succeed or fail together may no longer do so. The change therefore belongs to the application’s own design, alongside its account loading requirements.
The consequences for a user depend on where the incompatibility occurred. An operator can miss participation, an RPC can return stale information and an application can build a transaction that no longer fits. The first two can be addressed by restoring compatible infrastructure, while the third depends on the transaction and the active rule.
A check of Solana’s recovery should keep those observations separate. It should compare vote records for operators, service records for providers and execution results for affected applications. Doing so makes it possible to identify a narrow effect even if the network continued producing blocks throughout.
The November deadline gave operators a named release and an epoch boundary. The durable record of its impact will come from what nodes did around that boundary and the service they were able to provide after it.
What to Watch
- Compatible releases: Anza’s schedule and the release notes can establish the mainnet floor and its equivalents across clients.
- Voting participation: Active stake and vote credits can show whether voting participation changed around the boundary.
- Network confirmations: Block and confirmation records can show whether the network continued processing transactions around the change.
- Exchange operations: Venue notices can establish whether an exchange paused its own Solana deposits or withdrawals.
FAQs
Does an old validator release mean Solana stopped?
An outdated operator can fall out of step while compatible validators continue to follow the network. Block production and active stake show how the chain performed, while a specific vote account or RPC service can establish what happened to an individual operator.
Why was Firedancer mentioned?
Different validator clients need compatible releases that apply the same active network rules. Anza’s warning named Firedancer 26.10.6 alongside Agave 4.4.1. Operators were expected to install the compatible release for the client they run.
Can the upgrade affect staking rewards?
A validator that stops participating effectively can miss votes. Delegators would need the validator’s vote credits and reward records to establish the effect.
Does a confirmed transfer guarantee immediate exchange credit?
An exchange applies its own confirmation and operating policies. The chain may record a transfer before the venue makes the balance available.
What is a feature gate?
A gate enables a specific rule on a cluster. Operators can install a release containing the rule before the cluster switches it on, giving them time to prepare their infrastructure. Once the gate activates, a node needs to apply the same rule as its peers when it processes a transaction.
What is a ProgramData account?
Solana’s upgradeable loader uses a ProgramData account to hold executable program data. The patch changes the minimum size attributed to this account when a transaction loads it. The difference matters most for transactions that were already close to their loaded account data limit.
Did every operator have to install Agave?
Operators using Firedancer had a corresponding compatible release. The objective was for their node to implement the active rule correctly, regardless of which supported client it used.
How can a delegator check for an effect?
The validator’s identity and vote account give a starting point. Comparing vote credits and rewards over the relevant epochs can show how that validator performed before and after the planned change.
Disclaimer: This article is for informational and educational purposes only and does not constitute financial, investment, legal or tax advice. Cryptocurrency activities carry risks, including loss of funds. Readers should conduct their own research and consult a qualified professional where appropriate. Information reflects publicly available material as of 9 November 2026 and may change as new information becomes available.
