Infrastructure for L1 and L2 Chains Before and After Mainnet
Protofire builds infrastructure for L1 and L2 chains: the endpoints, explorer, Safe, subgraphs and oracle checks that Chainlink, The Graph and Safe ask for. The admin roles end on your own Safe. Rootstock, Immutable and the Optimism Foundation each name Protofire in connection with Safe on their own pages.

Reviewed by Luis Medeiros, Field CTO at ProtofireLast reviewed: November 2026
On this page
Work shipped for 60+ networks and 95+ protocols, including
What a chain team needs before mainnet
Before mainnet, a chain team gets requests from other projects, and each answer depends on a different party. The team commissions some of the work, and another project decides the rest. Protofire builds the infrastructure for L1 and L2 chains that a chain team can commission.
For example, your testnet runs and the mainnet date is set. Then three requests arrive in one week. An oracle team asks whether the chain has three independent RPC providers. A treasury asks where it can create a Safe. A DeFi team asks where it can verify its contracts.
Who owns each part of a chain's launch infrastructure
The chain team keeps the protocol and its own keys, including the admin roles in the services Protofire builds.
Client and stack
Upgrade and admin Safes
Oracle, indexing and wallet support
RPC and archive endpoints
Explorer
Safe contracts and services
Subgraphs and oracle checks
Chainlink, The Graph and Safe each set rules for a new chain
Before Chainlink integrates a chain, its published list asks for three independent RPC providers and an archive node from genesis.The list also asks for an explorer with verification APIs and an audited multisig wallet with its own interface.
The Graph and Safe work the same way. The Graph Council approves mainnet support for a new chain. Safe's own team signs the transaction that puts Safe's contracts on a chain.
A chain can wait for those answers before it builds. In that case, protocol teams find no price feed, no Safe and no explorer to verify against when the chain opens.
Protofire prepares endpoints, contracts and documents to each of those lists. We cannot promise the approvals.
What a chain team commissions and what each ecosystem decides
A chain can commission the engineering behind each ecosystem's entry rules, but the ecosystem keeps the decision.Chainlink calls its list "for reference purposes only" and "subject to change". Each row was read against the project's published documentation in November 2026. Safe also decides on a native listing in its own interface.
Price feeds
What the chain team commissions: The chain team commissions each item on Chainlink's list, from three RPC providers to an explorer that verifies contracts.
What the ecosystem decides: Chainlink decides whether it integrates the network and for which services. Those services "may have unique requirements" on top of the list.
Indexing
What the chain team commissions: The team commissions RPC, Firehose or Substreams endpoints and reference subgraphs, under The Graph's integration process.
What the ecosystem decides: The Graph Council "reviews the request and approves mainnet support" after a forum thread, validation and a GIP.
Safe contracts
What the chain team commissions: The team commissions a chainlist.org entry, a funded deployer and one registry pull request per chain, version and deployment type (Safe factory).
What the ecosystem decides: Safe's own team signs the factory transaction and reviews each registry pull request.
Our record: Safe on chains, Glif RPC, Chainlink and The Graph
Three chains and foundations name Protofire in connection with Safe on their own pages.Protofire's work on Safe goes back to 2018. We deployed Safe on 120+ EVM networks, where it secures $2B+.
The Optimism Foundation selected Protofire for its Superchain Safe mission in December 2023. The mission covered the Safe interface and the services behind it on OP Chains. The Foundation closed the mission as completed in January 2025.
Rootstock's blog of 3 October 2023 says Safe was integrated into Rootstock with Protofire and Sovryn. The same post says Protofire is "committed to delivering ongoing support, maintenance" for that integration. Immutable's documentation, modified 5 November 2026, lists its Safe multisig as a "fork maintained by Protofire".
Protofire built and runs the Glif public RPC endpoint for Filecoin. Filecoin's newsletter of 29 May 2024 thanked "the Protofire team for running Glif Nodes RPC". That service topped Filecoin's first retroactive funding round. Our case study describes the build.
Protofire is a Chainlink core contributor and helps maintain Chainlink CCIP. Under a 2022 Chainlink Community Grant, we built the Chainlink Hardhat plugin and Foundry toolkit. Both tools are now in Chainlink's smartcontractkit organization.
Protofire was a top-3 Graph indexer by indexing rewards from 2020 to 2024. We have built subgraphs since 2019.
What infrastructure for L1 and L2 chains gives your team
RPC and archive endpoints measured for Chainlink's list
Protofire builds full and archive nodes from genesis behind public endpoints on your domain. We measure each endpoint over the window that Chainlink's list uses. Chainlink judges whether an endpoint we host counts as one of its three providers. The RPC node hosting page has the detail.
A Blockscout explorer where integrators verify contracts
Protocol teams verify their contracts against your chain, and your own team reads each owner and role in the system contracts. Protofire deploys Blockscout set up for your stack, with the verification API that Chainlink's list asks for.
Safe contracts and services from the first day of mainnet
Treasuries, DAOs and the foundation can create a Safe at launch. Safe can then serve as the audited multisig that Chainlink's list asks for. Protofire puts Safe contracts on the chain through the singleton factory and files the registry pull request. We also stand up a Transaction Service and an interface in your cloud account, as described under Safe multisig deployment.
Reference subgraphs that apps can query on launch day
Builders can read your bridge, token and staking contracts without writing their own indexers. Protofire writes the reference subgraphs and runs a Graph Node until The Graph Council approves the chain.
Chainlink checks, interim oracle feeds and CCIP token pools
Before you apply, you learn what Chainlink's list will fault, and each item comes with a proposed fix. The checks cover opcodes, the finalized tag, error mapping and transaction types. Until Chainlink integrates the chain, Protofire connects feeds from another oracle provider that you pick. Once CCIP adds the chain, we build the token pools for your token. Our oracle integration and CCIP integration pages have the detail.
Upgrade rehearsals on testnet for your signers
Your signers go through an upgrade on testnet before mainnet. Protofire prepares each upgrade payload as a Safe transaction and rehearses it. We change the stack itself through rollup development.
Who can upgrade a rollup depends on its stack
The stack's contracts name the owner of a rollup's upgrade keys.On OP Stack and ZK Stack, part of that authority can be held outside the chain team.
On chains Optimism governs, the L1 ProxyAdmin owner is "a 2-of-2 multisig" of an Optimism Foundation 5/7 multisig and the Security Council multisig (Optimism).
An Arbitrum chain gets two Upgrade Executors, and any holder of EXECUTOR_ROLE can upgrade protocol contracts (Arbitrum).
On a ZK Stack chain, the operator's multisig owns ChainAdmin. Shared contracts such as Bridgehub answer to the ProtocolUpgradeHandler, and DecentralizedGovernance owns that handler (ZKsync).
Stage 1 adds further requirements. ETHBEAT (formerly L2BEAT) sets them in its Stages framework. A rollup that claims Stage 1 needs a Security Council of at least 8 participants with a 75% threshold. Upgrades from outside the council need an exit window of at least 5 days. Since 30 April 2026, an optimistic rollup also needs a challenge period of at least 5 days (ETHBEAT forum).
The only way (other than bugs) for a rollup to indefinitely block an L2→L1 message (e.g. a withdrawal) or push an invalid L2→L1 message (e.g. an invalid withdrawal) is by compromising ≥75% of the Security Council.
How the work goes from testnet to keys on your Safe
- Step 1
Services set up on testnet
Protofire reads the chain against Chainlink's list, The Graph's process and Safe's factory rules. Then we bring up the endpoints, the explorer, the Safe contracts and the subgraphs on testnet. - Step 2
Signers named and admin roles moved to the Safe
The foundation picks the signers, a threshold and the device that holds each key. The foundation then creates the Safe that will own upgrades, separate from the Safe that holds treasury and grant funds. Right after deployment, the admin roles are held by the address your team named at creation, often a deployer key. On an Arbitrum chain, the Safe receives EXECUTOR_ROLE on both Upgrade Executors, and the deployer loses that role. On ZK Stack, ChainAdmin moves to the Safe. Protofire prepares each transaction, and your key signs it. - Step 3
Owners checked on the explorer
After each transfer, your team reads the owner of each proxy and role from verified contracts on the explorer. The address list then goes into your docs. Three misses recur at this point. A role is granted on the child chain's Upgrade Executor and missed on the parent chain's. A deployer keeps EXECUTOR_ROLE. Signer keys are held mostly by one company, and ETHBEAT counts such keys as one participant. Protofire then runs an upgrade end to end on testnet. - Step 4
Who runs the services after mainnet
The chain decides who operates the endpoints and the explorer after mainnet. The chain's own staff can operate them, or Protofire can, under a written scope. Either way, the services run in a cloud account the chain owns. Deployment code and monitoring are stored in your repository, so your staff can take a service over without a rebuild.
How work with Protofire starts
Protofire's first written proposal goes through each launch dependency.For each one, the proposal says who decides it and what we would build.
- 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 this work is not the right fit
- You want one provider to run the entire rollup. Protofire's work leaves the sequencer, batcher and proposer with your team or its provider, so a Rollup-as-a-Service provider fits better.
- You want a private institutional chain built with its stack's owner. Our institutional blockchains guide compares the options.
- You want a guarantee of Chainlink feeds, Graph support or a Safe{Wallet} listing. Chainlink, The Graph and Safe each make that decision themselves.
- You want Protofire to hold upgrade keys or serve on your security council. Once mainnet opens, your upgrade, admin and treasury Safes have no Protofire signer. Protofire prepares transactions, and your signers sign them.
A chain team is ready to start with Protofire once its client or stack is chosen and a testnet runs.
Chain infrastructure on Filecoin and Midnight
Protofire built and runs the Glif public RPC endpoint for Filecoin, its node stack and an RPC proxy for routing and caching.
DIA's oracle contracts were re-expressed in Compact, and its feeders were rebuilt on the MidnightJS SDK. Midnight is a non-EVM chain with no oracle layer.
FAQ
What is infrastructure for L1 and L2 chains?
Who can build the infrastructure around a new L1 or L2 chain?
Can Protofire get our chain supported by Chainlink, The Graph or Safe{Wallet}?
Does this infrastructure work on a non-EVM chain?
Does Protofire run validators for a chain?
Who holds the Blockscout commercial license for our explorer?
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.
