RPC — Your Connection Layer

On 2026-07-15 the default PulseChain gateway — the address most wallets ship with — refused connections for over fifteen hours.  Across the ecosystem the symptoms looked unrelated: wallets "broken," dapps showing "RPC not accessible," dashboards stalling.  One cause, many costumes.

• Eyes vs hands — every dapp page has two data paths.  The site's eyes (prices, quotes, charts) go through the operator's own backend and can look perfectly healthy.  Your wallet's hands (your balances in the popup, broadcasting anything you sign) go through your RPC.  With a dead wallet gateway you can watch a healthy dapp all day and still be unable to act on it.
• Down vs blind — a page that loads fast but never shows chain data isn't down, it's chain-blind: its single gateway died behind it.  The diagnostic question users never know to ask: "is the site down, or is the site blind?"
• The taxonomy the storm proved — apps with their own infrastructure sailed through; apps with multi-gateway fallback degraded gracefully; single-default apps went functionally dead while their HTTP stayed green.  Loudness and infrastructure are uncorrelated.
• The reassurance fact — a blind frontend puts no funds at risk.  Pools and balances live on-chain whether or not a dashboard can see them; a frontend outage is not a protocol outage.
• "My wallet flipped to Ethereum by itself" — almost always benign: dapps send network-switch requests, and several wallets fall back to Ethereum after RPC failures.  The flip moves nothing; the only risk is signing on an unexpected network.  Habit: glance at the network name before every signature.
• The herd effect — when a default dies, everyone flees to the same top-of-list alternative, which then degrades under the stampede.  Keeping two known-good alternates saved is the cure.
• The flush — the storm's epilogue — when the routes healed, the backlog cleared in a burst: transactions signed during the blindness had been queuing in the mempool all along, and they confirmed together within a few blocks.  The chain lost nothing — sick gateways only hid the queue.  The only casualties were panic re-sends and abandoned signatures; patience was made whole in minutes.
• The flush left a receipt — on July 17 at 11:46 UTC (7:46 AM Eastern), three blocks inside two minutes paid one validator's fee address 248.09M, 53.09M, and 2.86M PLS in priority fees — 304M PLS, most of it a single stuck contract deployment that had bid roughly 15,000× the base fee during the blindness and finally confirmed in the burst.  The proof is public: blocks 27053465, 27053470, and 27053477.  The lesson inside the number: a fee bid signed in panic cannot be unsigned — it waits in the queue and pays what it promised.

Five weeks later the lesson ran in reverse.  After July, much of the ecosystem had migrated to the largest community gateway (rpc-pulsechain.g4mm4.io) — and on August 25–26 that gateway went down: 18 hours 21 minutes on the 25th and 15 hours 37 minutes on the 26th — about 34 hours in all — by the operator's own status page.  The official gateway answered at the chain tip throughout.  July's leaderboard, exactly reversed.

• A provider fails whole — every service under the operator fell in identical windows: both chains' RPCs, the testnet, the explorers.  That correlation is the signature of provider-level failure, and it is why independent operators, not extra URLs on one host, are what a fallback list needs.
• Data services are RPC clients too — PulseChain pairs reportedly stalled on the biggest external charting site while wallets pointed at the dead gateway couldn't swap; the chain itself never missed a block (Piteas's same-day explainer named the failing provider and the affected classes — "many protocols, wallets, DEXs, and tools like DexScreener").  An app that never touches your wallet can still be your outage — and most users' first symptom.
• The herd effect completed its cycle — July's refuge became August's single point of failure.  Fleeing to the best endpoint moves concentration; it never reduces it.  Only holding several — in the app, in the wallet — removes the failure unit.
• What held — apps rotating across independent gateways crossed both storms without an incident, and the measured record below caught the failure as it happened: the August 25 13:15 UTC probe recorded the timeout while three other gateways answered at tip — the public file /data/rpc-health.json keeps each day's worst reading (August 25: red, a 10.2-second timeout), and anyone can recreate the probe with the one-call method described under the failover technique below.
• What fixed it: nobody — the outage ran about 34 hours across two days; users who recovered did so by switching endpoints, same as July.  Nothing structural changed — which is exactly why the pattern is now written down as a standard any wallet or app can adopt.

• Cannot — steal your keys or move your funds.  Keys never travel to the gateway.
• Can — lie about what you see (balances, incoming payments, prices, gas, transaction status) to get you to send, sign or hand something over; see your signed transaction before anyone else, and delay it, drop it or trade ahead of it; and log your addresses together with your IP — linking identities you meant to keep separate.  It cannot sign for you, but its lies can get you to sign: a malicious gateway is a surveillance-and-deception risk, and the deception can become theft through you (a documented fake-balance scam).
• Mitigations, in order — against lies and outages, keep a second endpoint to cross-check what you see; against logging, use fewer gateways, only from sources you'd trust with your address history, with Tor or Onion routing to weaken the address-to-IP link — and ultimately, run your own node, the only gateway that answers to you.  Every extra gateway you add also sees your addresses.

• MetaMask — a network can hold several RPC URLs since late 2024: menu (top right) → Networks → ⋮ beside PulseChain → Edit → Default RPC URL → Add RPC URL (on mobile: the network list → ⋮ → Edit → RPC URL → Add RPC URL), then switch between saved gateways from that same dropdown — no re-pasting during an outage (MetaMask Help Center).  Add two alternates on a calm day; switching takes five seconds on a stormy one.
• Rabby — handles endpoints for its integrated chains internally with automatic failover.  PulseChain is not one of them: it is added under Settings → Add Custom Network, which holds one RPC URL — to change gateways, edit that network.  Two verified cautions: Rabby validates a pasted URL by querying its chain ID before accepting — pasting a dead gateway fails the add with no clear error (observed first-hand 2026-07-16); and Rabby has confirmed PulseChain is not officially supported — assets are safe but the custom-network path is the only route, so the automatic failover does not cover PulseChain.
• Internet Money Wallet — PulseChain-native and community-battle-tested (live since 2021, publicly active founder).  Its open-source code holds one RPC per network, and its PulseChain gateway is rpc.pulsechain.com, set centrally by Internet Money — so it goes dark with the official gateway unless Internet Money changes it.  Keep a MetaMask profile as your storm spare.
• Any EVM wallet — the generic path: add PulseChain as a custom network (chain ID 369, currency PLS, explorer scan.pulsechain.com) with a gateway from the list below.  The RPC field is a trust decision, not a plumbing detail — paste only from sources you'd trust with your address history.

The open column — researched 2026-07-17 and re-verified against primary sources 2026-08-26 and 2026-09-22: no wallet documents automatic RPC failover on PulseChain that can be checked.  Two vendor claims exist, and the matrix records them as exactly that.  Pulse Wallet described an automatic "RPC Balancer" (two public gateways plus their private one) in an X post of 2025-01-02, with no documentation published since.  ZKX's team wrote during the July storm that "the wallet can automatically fail over to another" endpoint (X, 2026-07-15) — yet ZKX's own user manual documents only manual switching, down to advising you to switch back by hand when an endpoint fails; when marketing and the manual disagree, this matrix reads the manual.  Apps have learned rotation; wallets haven't shown their work.  The deepest fix for both storms is wallet-level automatic failover — the wallet is where balances render and transactions broadcast, so when its one gateway dies, every dapp looks broken at once; what a conforming wallet does is specified in the failover standard, section 5.  The column is earned by published documentation, not announcements — the first wallet to show its work owns it, and every cell updates the day documentation exists.  This matrix and the RPC line on every wallet card render from one shared source — an update lands once and both surfaces follow.

RPC failover is not proprietary and never was.  It stands on two openly published, widely implemented wallet methods any app may use — wallet_addEthereumChain (EIP-3085), which offers a new gateway, and wallet_switchEthereumChain (EIP-3326), which only switches to a chain the wallet already holds — plus ordinary timeout detection.  Both are formally Stagnant proposals that the major wallets ship anyway.  During the August 2026 storm the aggregator Piteas shipped the fullest version seen on PulseChain so far, within hours of the outage starting (their announcement, 2026-08-25); the implementation is theirs, the technique belongs to everyone.  Here it is, documented for any builder:

• Rotation (the app's own reads) — hold a short list of independent gateways; give each attempt one timed try (a ~9-second budget) and advance to the next on failure, remembering the last good seat.  Never retry a dead gateway in a loop, and never blank the page silently — show stale data with its timestamp, or an honest failure.  Health is measured with the same probe as our record below: one eth_blockNumber, timing the answer and comparing the height across gateways, because a fast stale answer is still a wrong answer.  The pattern's biggest adoption so far is the official PulseX interface itself: v1.1.5, released mid-July-storm, added automatic RPC failover with an Auto Mode across the official, G4MM4, and PublicNode seats plus custom RPC support (documented with Settings screenshots in Crypto Glider's July-storm write-up).
• Guided switch (the visitor's wallet) — an app cannot change a wallet's RPC, and shouldn't want to; it can offer.  When a confirm step times out, the app detects the wallet-side failure and calls wallet_addEthereumChain with chain 369 and a known-good gateway — the wallet shows the visitor an approval naming the URL, and nothing changes without their click.  State the consequence, offer the door, let the person decide.
• Where the known-good list comes from — a vetted, health-checked gateway list is the third leg; a hardcoded single alternate just recreates the herd.  The shared registry publishes at /data/rpc-registry.json (shaped for EIP-3085 consumption), and the measured record on this page publishes beside it at /data/rpc-health.json — for exactly this use.

The full written rules — registry, rotation, guided switch, query etiquette, and what a conforming wallet does — now live at the PulseChain RPC Failover Open Standard.

Every technique above manages someone else's gateway.  The endgame is the only gateway that answers to you: your own node — no rate limits, no herd, no operator to trust with your address history, and the seat the standard's ordering puts first.  The honest cost: roughly 2 TB of NVMe storage (a synced node uses ~1.1 TB and grows; a mechanical drive will never finish syncing), 32 GB of RAM comfortably, a few days of first sync, and a machine that stays on.  Three routes have made the setup itself genuinely approachable:

• The official route — PulseChain's own node repository added a Docker Compose setup in July 2026 (go-pulse execution + prysm-pulse consensus) that serves the RPC on the machine itself only.
• The one-command LAN route — David Feder's pulsechain-rpc-node: a Docker Compose setup (go-pulse execution + prysm-pulse consensus) that stands up a private LAN RPC in one install.  MIT-licensed, from a named author with years of public validator-tutorial history, and actively maintained (created 2026-07-18, last updated 2026-09-04).  It serves the RPC to your whole home network, so phones on the same Wi-Fi can use it.
• The step-by-step route — Dozza's PulseChain Node Guide: a complete, reproducible walk-through of one working build (go-pulse + Lighthouse in Docker, inside a Hyper-V VM on Windows 11), with the hardware table, firewalling, auto-recovery on reboot, and optional stall monitoring.  Built on the community's install_pulse_node installer, and honest about itself — it tells you to cross-check versions against the official node documentation rather than trusting any guide blindly, this page included.
• The one rule that is not optional — a home node's RPC ports (8545/8546) stay on your LAN or behind a VPN.  Exposed to the public internet, your node becomes a free public gateway within days and your home connection inherits the herd; both guides configure this correctly, and anything that undoes it undoes the point.

Every mitigation above manages a dependency; running your own node ends it.  A PulseChain node today is a pair — an execution client and a consensus client — on a 2TB NVMe machine — the consensus client checkpoint-syncs to the head quickly, the execution client's first sync takes days — serving your wallet an endpoint that never rate-limits you and never logs you.  The steps are in Run Your Own Gateway above; the habit this page asks of you is smaller: choose your gateway on a calm day, and keep a spare.

• Users — the five-minute defense:
  • Save two spare gateways on a calm day — five minutes, once.
  • Learn the eyes-vs-hands check.
  • Glance at the network name before signing.
  • Everything else on this list exists to protect people who haven't done this yet.
• Wallet creators — the missing feature, spelled out:
  • Ship multiple-RPC storage, one-tap switching, and automatic failover.
  • The capability matrix above shows the honest state: apps learned rotation; no wallet has documented it for PulseChain yet (MetaMask's built-in failover covers only its own Infura networks).
  • The first PulseChain wallet with auto-failover turns every future outage into a non-event for its users.
• Dapp and token projects — operations, not contracts:
  • Never ship a single-gateway frontend — rotate across gateways.
  • Fail loudly: "chain data unavailable" beats silent stale numbers.
  • Say plainly on your status page whether you're down or blind.
  • A fork inherits contracts, not operations — redundancy is an ops habit, not a repo file.
• Node operators — the storm's quiet winners: everyone on their own node never noticed.
  • The homework is capacity and openness.
  • Every additional public or semi-public endpoint — rate-limited is fine — thins the herd when a default dies.
  • A home node stays private.  Anyone who publishes an endpoint puts it behind rate limits, posts a privacy statement and a status page, and joins through the standard's operator door.
• Devs and robot builders — the lessons our own machines paid for that week, in order:
  • Rotate gateways with per-gateway strikeout memory.
  • Never cache a failure.
  • Stream logs unbuffered so the failure point is findable.
  • Probe with unretried single calls when measuring — retries mask the truth.
  • All four are now in this repository's daily runs.