Blockchain Infrastructure for Networks and Protocols That Run Their Own Nodes
Protofire builds and operates blockchain infrastructure for networks, rollup operators and protocols that run their own nodes. A written scope covers the right clients, snapshots that restore, disk headroom, hard-fork upgrades and monitoring. Since 2020 we have run Glif Nodes, a public Filecoin RPC service, and Filecoin's newsletter thanked us.

Reviewed by Arsenii Petrovich, Offer Owner at ProtofireLast reviewed: November 2026
On this page
Work shipped for 60+ networks and 95+ protocols, including
Running your own nodes through each hard fork
When your network schedules a hard fork, all the nodes you run have to be on the new release before it. Who updates them, in what order, and how will you know afterward that each one did?
Protofire builds your blockchain infrastructure and operates it under a written scope. We can also build the setup and hand it to your own engineers.
Layers of your blockchain infrastructure and who owns each
Each network publishes its fork dates and releases. Protofire runs the nodes, and you keep the records.
Fork dates and minimum releases
Sync paths and hardware minimums
Full and archive nodes
Rollup nodes
Upgrades and monitoring
Configs and release record
Snapshots
Why some nodes split off at a hard fork
A hard fork takes effect on a node only after its operator installs the new releases.In its Fusaka announcement, the Ethereum Foundation says that a node left on an old release will "disconnect from upgraded peers". So a node still on the old release splits off with the others that missed it.
Nodes also depend on machines outside their own host. A Base node reads an Ethereum L1 node and a beacon endpoint. An operator's own L1 node "needs to be synced before Base will be able to fully sync".
Support ends too. According to Optimism, op-geth reached end of support on 31 May 2026. After the Karst hardfork, op-geth cannot follow the canonical chain.
Fork dates move as well. On 22 October 2026, four days before Glamsterdam was due on the Hoodi testnet, the Ethereum Foundation announced a delay. Core developers had postponed that activation to investigate how one of Glamsterdam's EIPs interacts with mainnet contracts. So a plan that hard-codes a date breaks when the date moves.
If the upgrade is left to whoever has time, the failure arrives on fork day. Some of your nodes then run the old rules, and your explorer and indexers read from a node that has left your chain. Nothing records which release each node ran.
Ethereum network upgrades require explicit opt-in from node operators on the network. While client developers come to consensus on what EIPs are included in an upgrade, they are not the ultimate deciders of its adoption.
Our record: Glif Nodes on Filecoin since 2020
Protofire built Glif Nodes, a public Filecoin RPC service, and has run its public and dedicated Filecoin nodes since 2020.
- FilecoinFilecoin's newsletter of 29 May 2024 reported Glif Nodes first on the Fil-RetroPGF-1 list. The newsletter thanked "the Protofire team for running Glif Nodes RPC". Filecoin's mainnet documentation lists Glif Nodes among its RPC providers. Our Filecoin case study describes the node stack.
- LotusProtofire engineers contributed gateway methods to Lotus, the Filecoin reference node. They also maintain Lotus gateway builds and an Ethereum-RPC gateway for the Glif nodes, as the merged pull requests show.
- MonitoringFrom 2021 to 2023, Protofire published open-source monitoring templates for multi-cloud blockchain nodes. We also published automation for Gnosis Beacon Chain validators, Theta nodes and the Meter Passport relayer.
For nodes on Ethereum, OP Stack, Arbitrum, Base and Avalanche, Protofire follows each network's published rules, which are cited on this page.
What Protofire delivers for your blockchain infrastructure
Each network sets its own clients, sync path and fork calendar, so the scope is written network by network.
Client diversity across your nodes
Where a network has several clients, your nodes do not all run the same one. According to ethereum.org, ideally no consensus client would reach a 33% share of the total nodes. Protofire's written plan for each network names the client pair on each host. Where a network has one production client, releases are staggered across hosts.
Snapshots that have passed a restore test
A dead node comes back from a snapshot that has already been restored once. Syncing Filecoin from genesis "is no longer practical". A lightweight snapshot cannot answer an explorer's queries for historical state. So Protofire takes snapshots on a schedule and keeps a full snapshot where history is read. We test each restore on a fresh host, and the date and result are recorded in your runbook.
Disk growth forecasts for each node
Protofire gives you a headroom forecast that flags a node's disk well before it fills. For example, Avalanche's state sync starts near 500 GB and can pass 1 TB over months. We track each node's growth against the capacity that is provisioned.
Hard-fork upgrades with a release record
Before fork day, Protofire moves your nodes to the releases the network asks for. A record shows which release each node ran before and after the fork. We track releases for each client and take each release through testnet first. We also replace software that a network stops supporting.
Node monitoring with alerts that name the node
When a node lags the chain head or its peers drop, an alert names that node. The same happens when finality stalls or a disk runs low. The alert reaches whoever is on call during the hours written into the scope. Metrics come from Prometheus endpoints on the clients, and each alert rule is versioned in your repository.
Archive and trace nodes for explorers and indexers
Your explorer and indexers get the archive and trace nodes they need. The same node plan serves both Blockscout explorer deployment and subgraph development, and each is scoped separately.
How the work runs, from plan to handover
The same five steps apply to each network.
- Step 1
A written plan for each network
The plan lists the node roles (full, archive, rollup) and the client pair on each node. It names the endpoints a rollup node reads, who provides them and the hosting account. On Arbitrum, the database scheme is fixed when the database is created, so the plan sets the scheme before the first sync. - Step 2
Sync paths and a restore test
Each node client gets a sync path: snap sync, a snapshot, or checkpoint sync from a provider that the scope names. Ethereum.org says that "the third party providing the data is trusted and should be picked carefully". The step closes with a restore on a fresh host. - Step 3
Testnet nodes take each release first
The network and its client teams publish the activation point and the minimum release of each client. If a testnet node misbehaves after its fork, that release is held back from mainnet. - Step 4
Mainnet nodes move before activation
On Ethereum, both the execution and the consensus client change. Nodes restart in small groups, so the rest keep serving. On OP Stack, the execution clients move from op-geth to op-reth. After activation, Protofire reads head, finality and peers. A head stuck at the fork slot, stalled finality or a falling peer count points to a node that runs the wrong rules. - Step 5
Handover of the repository, snapshots and release record
You hold the repository, the snapshots and the release record. The release record lists each node and the releases it ran before and after the fork, so a later operator can read that history. If the nodes run in your own cloud account, you remove the access role that Protofire's engineers used, and the nodes keep running. If Protofire rents the servers, you get a written transfer list, node data and metrics history included, with a date for each item. A successor restores from the latest snapshot, checks each node against the release record and takes over the alerts.
How work starts and which keys the nodes hold
To start, you send Protofire the networks and the node roles and history each one needs, under NDA.You also send your fork calendar and any existing configs, with the secrets stripped.
Protofire's first proposal names each host and its client release. It also names the on-call hours and the hosting account, which is either a cloud account you own or servers that Protofire rents.
The full, archive and rollup nodes in this scope hold no validator, sequencer or batch-posting key. They hold no multisig or admin key either. These nodes hold only the JWT secret that lets an execution client and a consensus client talk, and each node's peer identity. The scope says where both are kept. It also lists each write call that those nodes make, and broadcasting your signed transactions is one.
For a bank or exchange, the scope states whether request logs are kept and who at Protofire can read them. So no shared node provider sees which addresses you query.
The risk and legal staff of an EU financial entity decide how its DORA register records the work. Protofire's guide to DORA third-party risk covers the register.
- Proposal
- In writing, one business day after the discovery call: findings, a plan in phases and the first step we recommend.
- Price
- Fixed per phase when you commission it, against written acceptance criteria. Overruns inside them are ours to absorb, invoices follow delivered milestones, and you can stop at any phase boundary. Anything we operate after launch is priced in the proposal as its own recurring line, with the notice to end it.
- Ownership
- Code we write for you, contracts, the keys and credentials this work creates and the accounts your infrastructure runs in are yours by contract, within the license of any third-party software involved. Keys that a custody platform or a staking provider holds under its own key model stay with it under your contract; every other custody key stays with you or the custodian you appoint. Where the scope places something on servers we rent, it says what moves to you and when. An NDA is available from your first message, and we sign a data processing agreement (DPA) together with it.
- After launch
- Delivery closes with a hypercare window and a defect warranty, with their terms written into the proposal. A service we operate continues under its written scope until that scope ends.
- Access
- Read-only by default. A role that can start requests only if your written scope names one; never a signer, approver, administrator, key holder or recovery role on your contracts, wallets or custody platform. Services we build call each platform on credentials your staff issue and keep in your vault. Anything that approves or moves funds runs in your environment, and a scope under which we operate a service lists every write call it makes. Where the scope has us operate nodes, validators, monitors, explorers or indexers, it names the role and any key we hold on those servers, and in your own cloud account you can remove it.
- Licenses
- Protofire is an engineering firm and holds no financial or crypto-asset license; licensed activity stays with you and your providers.
How we work shows a worked proposal.
When node operations with Protofire do not fit
A single endpoint, a provider's node platform, an undecided rollup stack and contract watching each have their own route.
- You need one RPC endpoint with published method limits. RPC node hosting provides that endpoint and also sends plain reads on large networks to shared providers.
- You want nodes on a provider's own platform, under its terms and support. You buy those nodes as a product from the provider, and you do not own a scope for them.
- The rollup stack is still open, or you want one vendor to operate the rollup for you. Rollup development covers the stack choice and those vendors.
- You need your contracts watched. Managed onchain operations covers contract watching, with incident responses prepared for your signers.
- Decentralization outranks convenience, and no outside operator should touch your nodes. Protofire can still build the setup and hand it to your own engineers.
Protofire's node work suits a network that has already chosen its clients and runs a testnet.
Node operations on Filecoin
Glif Nodes, a public Filecoin RPC service Protofire built, with its public and dedicated nodes and the open-source CID Checker.
FAQ
What is blockchain infrastructure?
Who can run and upgrade the nodes for our network or protocol?
How do full, archive, light and validator nodes differ?
Is there an availability target for our nodes?
Does Protofire run validator nodes as well?
How is Protofire's node work different from a node provider's managed nodes?
What decides the cost of running our nodes?
Get a proposal
Tell us what you are building. An engineer reads it, we have a short call, and the written proposal follows within one business day.
