Liquid Staking Index Vaults for DAOs, Chains and Asset Managers
Protofire builds the contracts for teams that launch a liquid staking index. The vault prices each LST at its issuer's rate, rebalances inside written bounds and exits through each issuer's queue. You hold the roles. Lido's grants organization has funded our Safe work on Ethereum testnets since 2023.

Reviewed by Diego Torres, Offer Owner at ProtofireLast reviewed: November 2026
On this page
Work shipped for 60+ networks and 95+ protocols, including
A liquid staking index needs a written price rule
A liquid staking index is one token over a basket of liquid staking tokens (LSTs), and its vault needs a rule for pricing them. Once you have decided to launch one, your engineers have to answer a question that the vote did not settle. Which price does the vault use when one LST trades below its issuer's rate?
The vault standards do not answer that question. ERC-4626, ERC-7575 and ERC-7540 define shares, entry points and redemption requests. None of them says how a basket is weighted or priced.
Who builds and who holds each part of a liquid staking index
You hold the roles. Protofire builds the contracts and tools. Each issuer keeps its rate and withdrawal queue.
Methodology and contract roles
Master vault and share token
Pricing, NAV and exits
Rebalance tooling
LST issuers
Price feeds and cross-chain messaging
Price, exit and loss rules for an LST basket
Three written rules decide whether a basket of LSTs holds up.The first rule is the price, and the price decides which holders absorb a gap. The vault can price a component at its issuer's exchange rate, read from the issuer's contract, or at the market price. The two prices can diverge. If the vault redeems at the exchange rate while the market values a component lower, holders who leave exit at par. The holders who remain then bear the price gap. If the vault prices at market, whoever enters or leaves at that moment bears the price gap. A vault with neither rule written down leaves the argument until the day a gap opens.
The second rule is the exit, and the withdrawal queues belong to the issuers. A Lido withdrawal request fixes the stETH it locks and caps the ETH paid out at that amount. A large loss can still finalize the request at a lower amount (Lido). A slashing loss arrives as a lower rate at the issuer's next report, and the index NAV follows. A redemption from the basket then waits on the slowest component, unless tokens are paid out in kind or by swap.
The third rule says who bears a loss once any reserve is spent. You decide this rule in the index terms, because after a slashing event the contracts can only apply what was written.
One more question comes before the weights are set. ESMA's guidelines of 19 March 2025 ask, among other things, whether capital is pooled from several investors and invested under a defined investment policy (ESMA). Your counsel decides whether a managed basket meets those tests, and the question is cheaper to ask before launch.
What Protofire builds for a liquid staking index
Protofire writes your price rule, exits and rebalance limits into contracts and tools.Three kinds of buyer ask us for an index build. One is a protocol or DAO whose governance voted a methodology. Another is a chain or LST issuer that wants one token over its ecosystem's LSTs. The third is a licensed asset manager issuing a tokenized basket. The first thing that fails for an asset manager is a dealing calendar that runs faster than the issuers' queues. Our page on tokenized funds from the manager's side covers the fund records around the vault.
A price rule written before anyone enters the vault
Each holder knows which price a mint, a redemption and a rebalance trade uses. Each holder also knows who bears the price gap when a component trades below its issuer's rate. Protofire builds a rate adapter for each component that reads the issuer's contract. We also build a depeg threshold at which mints and redemptions pause.
One share token over the LSTs you admit
You launch one share token with an entry point for each accepted LST and a cap for each component. Protofire builds the master vault with the mint and redeem price rule in code. We also build a test suite that runs a depeg, a removal and a queued redemption.
A NAV report your finance team can reproduce
Your finance team and auditors get a NAV report for each strike. The report lists each component's balance, rate, report time and source. Rocket Pool updates its rETH/ETH rate approximately every 24 hours, so the report records each rate with its report time. A rate older than your limit stops the strike and flags it. Protofire builds the adapters and the report to your cut-off and clock.
Redemptions that wait on each issuer's queue
A redemption is an ERC-7540 request that remains Pending until each component it needs is sold, handed over or paid out by its issuer. After that, the holder claims the redemption. A queued withdrawal is counted in the NAV at no more than the amount locked at request. Protofire builds the request flow, an exit path for each component and the claim of each finalized withdrawal.
Rebalances within your methodology's limits
The contracts hold four limits from your methodology. One caps each component, and another caps the weight move in each rebalance. The other two are a slippage bound and the venues a rebalance may trade on. A trade outside these limits reverts. Protofire builds the tooling that turns your methodology and the latest NAV report into proposed trades. We also build component admission and removal. Removal stops mints in a token, then sells or queues the token out.
Fee, pause and loss rules that holders can read
Each fee, threshold and pause setting has a role holder and a change notice, and a script reads each setting from the contracts. Protofire builds fee accrual on your fee terms and the pause and unpause roles. We build a reserve buffer where you fund one. Losses beyond the reserve fall on holders pro rata unless the index terms set another rule.
Our record: VaultOS, Balancer's ve8020 Launchpad and Safe
The risk in an index is in its vault accounting, outside review and who holds the roles.Protofire can point to work on each part.
VaultOS, the vault core we ship
VaultOS, Protofire's vault product, has an ERC-4626/7540 vault core. The core supports asynchronous subscription and redemption with queued redemptions. The core's Valuation Provider role strikes the NAV that requests settle against. The VaultOS page says the client keeps the vault contracts and the governance root once the deployment is done. A basket on that core still needs a rate adapter for each LST and the depeg rule. The basket also needs an exit path for each issuer queue and the rebalance bounds.
Balancer's ve8020 Launchpad, audited by Certora
Balancer's grants program funded Protofire in 2023 to build its open-source ve8020 Launchpad. The Launchpad is a vote-escrow staking framework for pools. Certora audited the Launchpad's Solidity contracts and published its report in March 2024. Our vote-escrow staking page describes this service.
Safe multisig for the index roles
The Safe Ecosystem Foundation wrote in May 2026 that Protofire "has been contributing to Safe since 2018". We deployed Safe on 120+ EVM networks, where it secures $2B+. In an index build, your Safe or timelock holds the manager, admission and pause roles. It also holds the fee and upgrade roles. Our Safe multisig deployment page has the details.
Safe on Ethereum testnets, funded by Lido's grants organization
Lido's grants organization (LEGO) funded Protofire to deploy Safe on the Holesky testnet in 2023 and on Hoodi in 2025. LEGO has renewed the maintenance grant each half-year through Q4 2026. LEGO wrote in January 2025 that the Safe infrastructure on Holesky is "used by so many different staking-centered protocols to ensure their processes and flows match mainnet". The grants cover testnets only.
How an index build with Protofire runs
- Step 1
Methodology reading and written proposal
An engineer reads your written methodology. The reading covers the inclusion rules, the weights and caps, and the rebalance cadence. It also covers the components and the Safe or timelock meant to hold the roles. You then get a written proposal. The proposal names what the first phase settles: the price rule for each action, the exit path for each component and the role table. - Step 2
First phase: vault, rate adapters and NAV report
In the first phase, Protofire builds the vault, the rate adapters and the NAV report. These parts come first because each later piece depends on the price rule. - Step 3
Next: exits, rebalance tooling, loss rules and the audit
Redemption management, the rebalance contract and its tooling, and the fee and loss rules come next. You pick an outside audit firm. The firm reviews the vault, the pricing adapters and the rebalance contract at one frozen commit that Protofire prepares. We fix what the firm reports. A review reports what it finds, but it does not certify the index. - Step 4
Handover: your repository, roles and keys
The repository, the runbook and the role table are yours. Protofire's scripts build the deploy transaction, and your engineer signs it with your key. The signed transaction gives the roles to your Safe or timelock, and no Protofire address appears among the role holders. Your staff install the rebalance tooling on hosts you run. You or the manager you appoint set the weights, admit each component and trigger each rebalance with your own key. Protofire holds neither those hosts nor that key.
How work with Protofire starts
Work starts when you send Protofire the written methodology and the components it names.Past rebalance records are shared under NDA, with holder data removed. The terms below apply to each phase, as our page on how we work sets out.
- 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 an index build is not the right fit
An index build covers the basket's contracts and tools.You or the manager you appoint manage the index, hold the admin and pause keys and receive any fee from the fund.
- Building a single receipt token for one network's stake, with its validator backend and exit queue, is liquid staking development.
- A custodian or exchange distributing someone else's basket needs the custody and ledger side, which our page for licensed crypto firms covers.
- Running the validator nodes behind an issuer's token is a separate validator operations engagement under a written scope.
- Exchange-rate or price feeds as a project of their own belong to oracle integration.
- An independent review of index contracts that another team wrote is a smart contract audit.
An index build suits a team with written or draft inclusion and weighting rules that wants the vault, pricing and exits built to them.
FAQ
What is a liquid staking index, and what does Protofire build for one?
Who can build a liquid staking index for a DAO, a chain or an asset manager?
Are there live liquid staking indexes today?
How does holding an index share differ from holding the LSTs directly?
What happens to the index when one component is slashed?
Can the basket hold LSTs from several networks?
Which vault standard fits a basket share?
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.
