← back to blog

Keeping a farm running through a chain outage

Every farm operator eventually hits a chain outage. A sequencer stalls, a validator set can’t reach consensus, an RPC provider’s node falls out of sync, or a testnet just stops producing blocks for an hour. It’s not rare and it’s not usually catastrophic, but it exposes exactly how sloppy or how disciplined your operation actually is. Wallets that were behaving indistinguishably from any other user during normal conditions can suddenly start behaving in ways that stand out, purely because of how you handled the downtime.

This isn’t about predicting outages or reacting emotionally to them. It’s about understanding the mechanics of what’s actually breaking, so your farm doesn’t turn a chain’s problem into your wallets’ problem.

What actually happens when a chain goes down

“The chain is down” covers a few distinct failure modes, and they don’t behave the same way from a farming perspective.

A consensus stall means validators aren’t finalizing new blocks. Transactions you submit sit in the mempool. Nothing confirms, nothing reverts, they just wait. Once the chain resumes, everything that was queued gets processed roughly in the order it arrived, assuming it’s still valid.

A sequencer outage on a rollup is different. The sequencer is a single point that orders transactions before they’re batched to the base layer. If it goes down, your transaction might never even reach the mempool in a meaningful sense. Some rollups let you force a transaction through the base layer as a fallback; most farming setups don’t bother with that path because it’s slow and gas-expensive relative to normal submission.

An RPC outage is not a chain outage at all. The chain is fine. Your access to it isn’t. This is the most common case for farmers because most wallets and scripts talk to the chain through a single provider, and that provider’s node can fall behind, get overloaded, or start serving stale state without saying so.

The reason this distinction matters is that each one calls for a different response, and treating them all the same is where the trouble starts.

The retry storm problem

The instinctive response to a stuck transaction is to retry it. Scripts do this constantly, often on a short timer, because that’s the simplest way to write automation. During a real chain stall, this is close to harmless since nothing is confirming anyway. During an RPC outage, it’s a different story: a provider might accept your transaction, fail to broadcast it, and return an error that looks like a network timeout rather than a rejection. Your script sees “no confirmation” and resubmits with the same nonce. If the first attempt actually did land somewhere, you now have two versions of the same nonce competing, and depending on gas price differences, either one could confirm.

Across a handful of wallets this is an annoyance. Across a farm running dozens or hundreds of wallets on synchronized cron jobs, it produces something more visible: a burst of near-identical retry behavior, timed to the same outage window, hitting the same RPC endpoints, with the same backoff interval because they’re all running the same script. None of that is a “sybil signal” by itself, but it’s exactly the kind of correlated, synchronized pattern that chain analysis looks for when clustering addresses. Independent users don’t usually retry in lockstep. Scripts pointed at the same infrastructure do.

Nonce management when blocks stop

Nonces are sequential per address, and that’s the part that turns an outage into a real operational risk rather than just an inconvenience. If wallet A has a transaction stuck at nonce 14, every subsequent transaction from that wallet queues behind it, whether it’s a genuine mistake or just a transaction that got dropped silently by a struggling RPC node. Nothing after nonce 14 will confirm until 14 is resolved, either by confirming or by being replaced with a higher gas transaction at the same nonce.

The operational habit that matters here is knowing your last confirmed nonce per wallet before the outage started, not relying on what your RPC provider’s eth_getTransactionCount (or equivalent) reports mid-outage, because that call can return stale or inconsistent values while a node is catching up. If you track nonce state locally and reconcile against multiple providers once service is confirmed stable, you avoid two failure modes: submitting duplicate transactions that fight each other, and leaving a wallet permanently stuck because a script assumed a nonce was free when it wasn’t.

What a stall does to clustering risk

Chain analysis firms and in-house platform detection generally don’t need any single signal to flag a cluster. They look for correlation: wallets that fund each other, wallets that transact in tight time windows, wallets that share gas price patterns, wallets that hit the same infrastructure. An outage compresses activity. When a chain resumes after a stall, there’s often a burst of transactions landing in the first few blocks, and if your farm’s wallets are disproportionately represented in that burst because they were all queued behind the same stuck RPC connection, that’s a timing correlation that didn’t exist under normal conditions.

The defensive principle isn’t about hiding from an outage. It’s the same principle that should already be in place day to day: wallets shouldn’t share a single RPC path, a single timing pattern, or a single retry policy if you can help it. Spreading wallets across independent RPC providers (not just different URLs pointing at the same underlying infrastructure) means an outage on one provider doesn’t produce a synchronized recovery burst across your entire farm. Staggering scheduled activity so it isn’t all queued at the exact same block height when service resumes reduces the same kind of correlation. None of this is about beating a specific detection system. It’s just recognizing that synchronized infrastructure produces synchronized behavior, and synchronized behavior is the raw material clustering runs on.

RPC providers: queuing versus lying

Providers differ a lot in how they behave under stress, and this is worth paying attention to when you’re choosing infrastructure, not just when things go wrong. A provider that’s honest about degraded state will return a clear error, or expose a status endpoint showing it’s behind head by some number of blocks, or refuse the request outright. A provider that’s trying to look reliable might instead serve a cached response, or return a “success” for a broadcast it never actually confirmed reached the network. The first kind is annoying but workable, because your automation can detect the error and back off. The second kind is the one that causes duplicate broadcasts and phantom confirmations, because your script has no signal that anything is wrong until state stops matching what it expects.

When evaluating an RPC provider for farm use, check whether it publishes a real-time status page you can poll or subscribe to, whether it exposes block height in a way you can cross-check against a second provider, and whether its documented error codes distinguish “your request failed” from “the network is degraded.” That distinction, not raw throughput numbers, is usually what determines whether an outage costs you a delayed batch or a genuinely broken nonce sequence.

A practical outage checklist

When you notice a chain isn’t behaving normally, the response that avoids most of the damage is fairly boring:

  • Stop new submissions from that farm’s scheduler rather than letting retries queue up blind.
  • Record last-known-good nonce per wallet from your own logs, not from a live RPC call during the outage.
  • Cross-check block height across at least two independent providers before assuming the chain, and not just your connection, is the problem.
  • Resume gradually and staggered rather than releasing every queued job at once the moment service looks stable.
  • Reconcile pending transactions after resumption before trusting any automated nonce increment again.

What not to do

Don’t chain-hop mid-task to a fallback network just because it’s live, if the campaign you’re farming is scoped to a specific chain. Activity that lands on the wrong chain usually just doesn’t count toward eligibility, and in some cases looks like exactly the kind of erratic, script-driven behavior that stands out. Don’t crank retry frequency up “to catch up” once service resumes, since that’s the surest way to produce the synchronized burst described above. And don’t treat an outage as a reason to abandon nonce discipline for the sake of speed. A farm that comes out of an outage with clean, reconciled wallet state is in a far better position than one that comes out faster but tangled.

An outage is a stress test you didn’t schedule. How a farm handles it says more about the setup behind it than almost anything that happens on a normal day.

For more on running proxy and cloud-phone infrastructure the way an actual operation should, and honest reviews of the RPC providers, wallets, and anti-detect browsers that hold up under conditions like this, head back to the homepage.

Get new guides and videos first — join the Telegram channel.

need infra for this today?