RPC — Your Connection Layer

The Night the Default Died — What July 15, 2026 Taught

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.

What an RPC Can — and Cannot — Do to You

• Cannot — steal your keys or move your funds.  Keys never travel to the gateway.
• Can — lie about what you see (balances, prices, transaction status), censor your transactions by dropping or delaying them, and log your addresses together with your IP — linking identities you meant to keep separate.  A malicious gateway is a surveillance-and-deception risk, not a theft risk.
• Mitigations, in order — use endpoints only from sources you'd trust with your address history; keep multiple endpoints configured; Tor or Onion routing weakens the address-to-IP link; and ultimately, run your own node — the only gateway that answers to you.

Switch Your Wallet's Gateway — Wallet by Wallet

• MetaMask — a network can hold several RPC URLs since late 2024: Settings → Networks → PulseChain → Add RPC URL, then switch between saved gateways from the dropdown beside the RPC field — no re-pasting during an outage.  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, and accepts a custom RPC per chain under More → Custom RPC.  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 (~4 years live, publicly active founder).  Its RPC-alternate flow is not publicly documented; until it is, treat it as single-endpoint and 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.

Which Wallets Speak Multi-RPC — the Capability Matrix

The open column — as researched 2026-07-17, no wallet ships automatic RPC failover on PulseChain.  Apps have learned rotation; wallets haven't.  The first wallet to earn that checkmark owns this column — wallet teams, the cell is yours to claim, and"not documented" rows update 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.

The Public Gateways — Copy, Paste, Keep a Spare

• https://rpc.pulsechain.com
• https://rpc-pulsechain.g4mm4.io
• https://pulsechain-rpc.publicnode.com
• https://rpc.pulsechainrpc.com
• https://rpc.gigatheminter.com

Chain ID 369 · currency PLS · explorer scan.pulsechain.com.  Every gateway above is probed daily for the record below.

The Reliability Record — Two Eras, Honestly Labeled

History here comes in two kinds and says which is which.  The incident era is mined from our own robots' logs — their actual retries, rate-limits, and failures, recorded while doing their daily work (records begin 2026-07-10, when the robots came online).  The measured era began 2026-07-17: one unretried probe of every gateway every six hours (00:22, 06:43, 12:43, 18:43 UTC), timed, with cross-gateway block-height comparison — the staleness check no single gateway can confess to.  The measurements publish as open data at /data/rpc-health.json — any app may reference them, and BluBox's Gateway Weather cites this source for seats a visitor's own browser cannot probe.

The buildup into the storm — day by day, class by class

The measured era — probed every six hours

This record answers "who has earned trust over time."  Right now from your chair is a different question, because routes differ — for that, probe the gateways live from your own browser and read what comes back in this same Red/Gold/Blu language.

The Only Gateway That Answers to You

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, checkpoint-synced in days, serving your wallet an endpoint that never rate-limits you and never logs you.  That build deserves its own page; until then, the habit this page asks of you is smaller: choose your gateway on a calm day, and keep a spare.

The Questions the Storm Taught Us — an FAQ

What Each Role Could Have Done — the Storm's Homework

• 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, wallets haven't.
  • 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.
  • Publishing your endpoint's existence, even for friends and family, is ecosystem service.
• 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.