Skip to content

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.

Luis Medeiros

Reviewed by Luis Medeiros, Field CTO at ProtofireLast reviewed: November 2026

On this page
  1. Overview
  2. Why it matters
  3. Who decides
  4. Why Protofire
  5. What you get
  6. Upgrade keys
  7. How the work goes
  8. How work starts
  9. Not the right fit
  10. Related
  11. FAQ

Work shipped for 60+ networks and 95+ protocols, including

  • Chainlink
  • Ethereum
  • Solana
  • Safe
  • Ripple
  • Aave

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.

Chain team

Client and stack

The chain team keeps the client or rollup stack, genesis, the sequencer or validator set and the token.

Upgrade and admin Safes

After launch, the chain's Safes or council own the upgrade, fee and admin roles.
Ecosystems decide

Oracle, indexing and wallet support

Chainlink decides on its integration, The Graph Council approves support, and Safe decides on a native Safe{Wallet} listing.
Protofire builds

RPC and archive endpoints

Full and archive nodes from genesis run behind public endpoints.

Explorer

A Blockscout explorer set up for the chain's stack verifies contracts.

Safe contracts and services

Safe contracts go on the chain through the singleton factory, with a Transaction Service and an interface.

Subgraphs and oracle checks

Reference subgraphs index the chain, and the checks follow what Chainlink's list asks for.

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.

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.
ETHBEAT (formerly L2BEAT), Stages framework specification, Rollup risk research site · Stage 1 requirement, updated 31 July 2025

How the work goes from testnet to keys on your Safe

  1. 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.
  2. 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.
  3. 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.
  4. 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

99.95%+
uptime, the result reported for the Glif deployment

Protofire built and runs the Glif public RPC endpoint for Filecoin, its node stack and an RPC proxy for routing and caching.

25
DIA price feeds served on Midnight

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.

DIA on MidnightView project

FAQ

What is infrastructure for L1 and L2 chains?
Infrastructure for L1 and L2 chains is the set of services a network needs around its client before builders arrive. It covers RPC and archive endpoints, an explorer, a multisig, indexing and price data. Protofire builds these services for chain teams and moves their admin roles onto the chain's own Safe.
Who can build the infrastructure around a new L1 or L2 chain?
Protofire can. We build archive and public RPC endpoints, a Blockscout explorer, and Safe contracts and services. We also write reference subgraphs, list the gaps against Chainlink's page and rehearse upgrades. The chain's team keeps the client or stack, genesis, the token and its keys.
Can Protofire get our chain supported by Chainlink, The Graph or Safe{Wallet}?
No. Chainlink decides against its published requirements. The Graph decides through Council approval of a GIP. Safe decides by its own priorities for app.safe.global. Protofire prepares the chain against each project's list.
Does this infrastructure work on a non-EVM chain?
Partly. Safe contracts and Blockscout serve EVM networks, and Chainlink's published list covers EVM networks. Node and RPC work depends on the client, such as Lotus on Filecoin. On Midnight, Protofire worked with DIA to re-express DIA's oracle contracts in Compact (case study).
Does Protofire run validators for a chain?
Protofire runs no validators under its own name or stake today. We can set up validator nodes for a chain's team, or run them for the chain. The chain holds the stake and each key that can move the stake. Two forum posts name Protofire's past validator work. A forum post of 8 December 2020 named Protofire among the xDai chain's 12 nominated validators. A Maker forum risk evaluation of 16 November 2022 named Protofire among the Ethereum to Gnosis bridge validators.
Who holds the Blockscout commercial license for our explorer?
Protofire's written proposal names who obtains the Blockscout Commercial License. Blockscout's license page asks a party "being paid to configure, deploy, or maintain Blockscout for a customer" to discuss a Commercial License.

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.

Luis MedeirosField CTO, reads every request · LinkedIn

A demo or repository link also works.