Skip to content

Validator Operations for Foundations and Custodians

Protofire runs validators for foundations and custodians under a written scope, or sets them up for their team. A key table names each key's holder. You keep the withdrawal address, account key and stake. Protofire was named an xDai chain validator in 2020 and an Avalanche Bridge warden in 2022.

Arsenii Petrovich

Reviewed by Arsenii Petrovich, Offer Owner at ProtofireLast reviewed: November 2026

On this page
  1. Overview
  2. What you get
  3. Why Protofire
  4. How it runs
  5. Terms
  6. Not the right fit
  7. Related guides and services
  8. FAQ

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

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

Which key moves the stake and which only signs

When your treasury is ready to stake, your security lead asks which key can move the money and which key can only sign. For validator operations of your own, the answer differs on each network, so it has to be written down before the first deposit.

Stake is lost at the signer. Secret Network's validator guide warns that "Two live copies of one consensus key double-sign" (Secret Network). On Secret Network, a double sign slashes 5% of the stake, jails the validator for good and tombstones it. A server change causes a double sign when it copies the key without its signing history, or when it leaves the old machine running.

If the key split is not written down, the first migration or restart shows who held what. The controls are a key table and a tested signer move. Neither control makes a second live signer safe.

Who holds each key and who runs each part of a validator

You keep the stake and the keys that move it. The scope says where the signing key is kept. Under that scope, Protofire runs the nodes and hands over the setup.

The client

Withdrawal address, account keys and the wallet that signs deposits, unjails and exits

The client holds the Ethereum withdrawal address, the Cosmos SDK account key and its self-bond and commission, and the Avalanche stake and reward addresses.
Client or Protofire, per scope

Signing key and signer

The signer signs proposals, attestations and block votes, and a slashing-protection record is kept beside it.
Protofire runs

Validator nodes, sentries and monitoring from chain data

The nodes are beacon, execution and validator clients on Ethereum, CometBFT nodes on Cosmos SDK chains and AvalancheGo on Avalanche.
Protofire builds

Setup and runbooks

Protofire puts the configs in your repository and writes the signer-move procedure and an exit runbook for each network.

What you get from validator operations with Protofire

Protofire's validator scope runs from a key table to an exit runbook.Each part leaves you something your team can run without us. The items below say what changes for you.

A key table before the first deposit

You know who holds each key before money moves, because Protofire writes a key table for each network. You send the deposit from your own wallet. On Ethereum, the first deposit processed for a signing key fixes the key's withdrawal credentials. Whoever holds that signing key can sign deposit data with credentials of its choice (consensus specs). So the check that your own address is named in those credentials comes before the deposit.

Signer moves that keep the signing history

In a server change, the old signer stops before the new one starts. The key's signing history moves with the key, so the new machine refuses a height that the old one already signed. Protofire writes the signer-move procedure for each network. On Ethereum, the procedure uses the EIP-3076 interchange file and Web3Signer's slashing-protection database. On Cosmos SDK chains, it uses the CometBFT state file.

An exit your team can run without us

Protofire writes each exit path as steps for your keys, and your team rehearses them on testnet. Since the Pectra upgrade, the Ethereum withdrawal address can start an exit through an execution-layer request (EIP-7002). On a Cosmos SDK chain, your account key unbonds the self-bond. On the Avalanche Primary Network, a validation with a fixed end time ends at that time. An auto-renewed validation stops at the end of its current cycle after its validator authority sets the period to zero. An Avalanche L1 validator leaves the set when the L1's validator manager sets its weight to zero.

Reports you can check on chain

You query the figures in Protofire's reports yourself, on chain. The figures cover duties and missed blocks, jail status, and where the fees went for each block your validators propose. We build the alerts to cover the hours that the scope names. We also keep an upgrade log for each network, which records the version that each node and signer runs.

Node setups you can audit

On Ethereum, the scope names each node's beacon, execution and validator clients. The client choice in the scope avoids a client that most of the network runs. You choose whether to use MEV-Boost and through which relays, and the scope records your choice.

The signing keys allow the operator to perform validator duties (attesting and proposing blocks) on your behalf. Misusing them can get your validator penalized or slashed, but they cannot be used to withdraw, transfer, or spend your funds.
ethereum.org, Staking as a service guide, Ethereum community website · Staking as a service page, read November 2026

Our validator record: xDai chain and Avalanche Bridge, 2020 to 2022

Third parties named Protofire in validator roles from 2020 to 2022.Our own public code from 2020 covers validator failover.

Protofire runs no validators of its own today.

Validator of the xDai chain and of its bridge

In December 2020 the xDai chain's team listed Protofire among the 12 nominated validators that secured the chain (Maker forum). The xDai chain is now Gnosis Chain. A November 2022 risk evaluation named Protofire among the validators of the bridge between Ethereum and Gnosis Chain (Maker forum).

Warden of the Avalanche Bridge

In July 2022 Ava Labs listed Protofire among the eight wardens of the Avalanche Bridge (Aave forum).

Polkadot validator failover with one signer at a time

Protofire's public GitHub repository holds an open-source Terraform failover setup that we built in 2020. The setup runs Polkadot validator nodes across three cloud regions, so only one node validates at a time (GitHub). The failover setup addresses the same concern as a signer move between servers: one live signer per key.

Top-3 indexer with slashable stake on The Graph

From 2020 to 2024, Protofire was a top-3 Graph indexer by indexing rewards. An indexer puts GRT at stake on The Graph's network. The Graph's docs say that this stake can be slashed when an indexer serves incorrect data or indexes incorrectly (The Graph).

How a validator engagement with Protofire runs

You send the networks, the stake on each network, and the wallet or custodian that will hold the withdrawal address and account key.The steps repeat for each network.

  1. Step 1

    Key table in the first proposal

    The first written proposal includes the key table. The table names each key, where the key is generated and where it is stored. It also names who holds the key and each transaction that Protofire's nodes or scripts may sign. Your security team signs off the table before the first stake moves.
  2. Step 2

    Where the signing key is kept: three models

    The three models differ in one place, the signer, and the choice of signer sets the slashing risk. In all three models, you hold the keys that move the stake. Client-held signer. Protofire operates the nodes, and the signing key is kept in a signer that you control. On Ethereum, the scope can name Web3Signer running in your cloud account. Web3Signer then reads keys from your HashiCorp Vault or Azure Key Vault. Web3Signer "must load private keys into memory for Eth2 signing" (Consensys), so that memory is in your account too. On a Cosmos SDK chain, the scope can name tmkms with a YubiHSM2 or Ledger that you hold (tmkms). AvalancheGo creates its node secrets in its own staking folder, so on Avalanche the node itself runs in your account. Protofire's signer. Protofire runs the nodes and the signer. The scope names the signer software and the one signer that each key runs in. The scope also names where the slashing-protection data is stored and which Protofire roles can reach those machines. A key on our machines can get the stake slashed on Ethereum and Cosmos SDK chains. On Ethereum, that key can also force a voluntary exit, and the exit balance goes only to the withdrawal address. Your own team. Your team runs the nodes and the signer, and Protofire sets them up. The handover covers the configs in your repository and the slashing-protection setup. It also covers alerts on chain data and the signer-move procedure. Support after the handover runs on access that you grant.
  3. Step 3

    Testnet first, then mainnet

    The nodes, the signer and the monitoring go up on the network's testnet first. The signer move and the exit are rehearsed there. Each restart keeps one live signer per key.
  4. Step 4

    The keys, stake, configs and runbooks are yours

    In all three models, you keep the withdrawal address, the account key and the staked assets. The configs and runbooks are yours as well. Your team runs the validators, or Protofire operates them under a written scope. The runbook includes a signer move, with the key's signing history, to another operator or back to your team.

Shared terms for each phase of validator work

Each phase of the work runs on the shared terms below.Our how we work page has the detail.

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 validators of your own do not fit

Validators of your own need an operator and a key table.A provider, a contract or plain delegation can cover the stake without either.

  • You want staking by API from a provider, with reports and a product that your clients see. The provider runs the validators. The Kiln integration page covers checking Kiln's crafted transactions before custody signs. The Figment integration page covers tying Figment's statements to client books. The Blockdaemon integration page covers posting reward events to a ledger.
  • You want staking built into your own product, with its own contracts, unbonding queue and app flow. The native staking module covers that build, and it runs no validator nodes.
  • Your stake is small and you have no reason to own a validator. On a Cosmos SDK chain, delegation moves the tokens into a staking module account, under a delegation record that you own. The tokens return to your account when unbonding completes.
  • You want the operator to hold the withdrawal address or the account key. In all three models, Protofire holds neither of them.

FAQ

What is validator operations?
Validator operations means running the nodes that sign a proof-of-stake network's blocks and votes for a stake. It also means keeping those nodes signing through upgrades, signer moves and exits. Protofire offers validator operations under a written scope, or sets them up for a client's team. A key table names who holds the signing, withdrawal and fee keys.
Who can run validators for a foundation or a custodian that keeps its own withdrawal address?
Protofire can run the nodes under a written scope or build the setup for your own team, and you keep the withdrawal address and the account key. Third parties named Protofire to validator and warden roles from 2020 to 2022. Kiln, Figment and Blockdaemon also run validators, but through a staking API that leaves the signing keys with the provider.
Can Protofire withdraw or move our stake?
In all three of Protofire's validator models, Protofire has no power to withdraw or move your stake. On Ethereum, exited ETH goes only to the withdrawal address you set, and that address cannot change once it is set. On Cosmos SDK chains, the self-bond is a delegation owned by your account key. On Avalanche, the stake returns to the addresses it came from.
Who pays if my validator is slashed?
The protocol takes a slashing loss from the stake, which is yours. Ethereum and Cosmos SDK chains slash a validator that signs twice. The scope states who bears a loss caused by a signer on Protofire's side. Avalanche has no slashing.
What happens when my validator is jailed for downtime?
On Secret Network, a validator that misses more than half of a 22,500-block window is slashed 0.01% and jailed (Secret Network). The validator remains jailed until the account key, which you hold, signs an unjail. Under the runbook, your signer sends the unjail once the jail period ends. Ethereum penalizes missed attestations but does not slash for downtime.
Who receives the fees from a block my Ethereum validator proposes?
The fee recipient address receives the fees. The validator client passes that address to the beacon node, which passes it on to the execution node. Lighthouse's docs treat each hop as a trust assumption (Lighthouse). The scope sets your address as the fee recipient. A relay block can name the builder as the recipient, and the builder then pays the proposer in a separate transaction. So monitoring checks both the recipient and the builder's payment.
What does my firm enter in its DORA register for validators Protofire operates under a written scope?
For an EU financial entity, the closest entry is "ICT operation management (including maintenance)" (S14 in Annex III of Implementing Regulation (EU) 2024/2956). The entry fits both validators that Protofire operates and a setup it hands over. Your risk team and counsel decide what is entered. Our DORA third-party risk guide explains the register.

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.

Arsenii PetrovichOffer Owner, reads every request · LinkedIn

A demo or repository link also works.