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.

Reviewed by Arsenii Petrovich, Offer Owner at ProtofireLast reviewed: November 2026
On this page
Work shipped for 60+ networks and 95+ protocols, including
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.
Withdrawal address, account keys and the wallet that signs deposits, unjails and exits
Signing key and signer
Validator nodes, sentries and monitoring from chain data
Setup and runbooks
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.
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.
- 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. - 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. - 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. - 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.
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?
Who can run validators for a foundation or a custodian that keeps its own withdrawal address?
Can Protofire withdraw or move our stake?
Who pays if my validator is slashed?
What happens when my validator is jailed for downtime?
Who receives the fees from a block my Ethereum validator proposes?
What does my firm enter in its DORA register for validators Protofire operates under a written scope?
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.
