# Overview ### Introduction RockSolid is a single-click integrated DeFi Vault platform that makes it simple for users to access the best DeFi rewards. RockSolid Vaults are institutional-grade DeFi vaults built for ETH-native ([ERC-20](https://ethereum.org/en/developers/docs/standards/tokens/erc-20/)) assets. Each vault is secured by [audited](https://docs.lagoon.finance/resources/audits) smart contracts, institutional MPC controls, and leverages curated strategies to provide depositors with rewards. RockSolid does not hold depositor private keys, strategies are executed by professional managers, and rewards flow back to depositors automatically. ### The Problem We're Solving #### For Depositors Accessing DeFi requires juggling multiple assets, protocols and chains. Users must manage bridging, staking, restaking, or lending positions, monitor risks, and manually reinvest rewards. The process is complex and prone to mistakes, and requires being online 24/7. #### **For Protocols** Protocols and asset issuers need to bootstrap and retain liquidity. Incentive programs are expensive and often attract short-term capital. Liquidity is fragmented across chains and strategies, making it difficult to sustain deep markets. Building and integrating custom vaults with a variety of infrastructure and curator partners is time consuming. #### Shared Challenges * Risks are unclear and constantly evolving. * No standardized visibility into NAV, validator performance, or DeFi strategy health. * Capital often sits idle or leaves ecosystems after short-lived incentives. ### **RockSolid’s Approach** RockSolid solves these issues by providing vaults designed for crypto-native rewards: * **Single-click experience:** Users can deposit assets with a single click. No complex DeFi transactions to execute and manage. * **Seamless integration:** RockSolid vaults are integrated directly into partner protocols for a seamless user experience and ‘zero lift’ from the partner protocols (see the Rocket Pool rETH vault as an example). * **Standardized Contracts:** Built on [ERC-7540](https://eips.ethereum.org/EIPS/eip-7540) Asynchronous Tokenized Vault Standard, (inheriting from OpenZeppelin’s [ERC-4626](https://docs.openzeppelin.com/contracts/5.x/erc4626)) * **Institutional-Grade Controls:** MPC wallets enforce transaction controls and operational limits. * **Professional Management:** Strategies managed by experienced teams with monitoring and guardrails. * **Transparent Economics:** Auditable onchain vault logic distributes rewards to depositors, shares fees with protocol partners and shows onchain positions. ### RockSolid Service Offerings RockSolid also designs and develops custom DeFi vault infrastructure for third-party partners. In addition to the software development services, RockSolid provides business and technology consulting services to blockchain protocols, asset issuers, and institutional partners. Our team advises partners on strategy, architecture, and deployment of DeFi vault solutions. #### Infrastructure Development * Advise on specific vault design for protocols and asset issuers to create the best DeFi vault for partners * Scope out the integration timeline and requirements * Deploy smart contracts for the vault and create backend infrastructure * Setup MPC wallet signing workflow and create vault policy parameters * Integrate the vault into both the RockSolid frontend and the customer frontend (if required) * Create weekly strategy reports related to vault performance #### Vault Advisory Services * Provide operational guidance on risk parameters and how to unwind/deleverage positions * Serve as a co-signer to ensure appropriate business continuity and disaster recovery in the event of the death, disablement, key loss, hack, compromise, key hijack or other unavailability of signers * RockSolid team will be available as-needed for any questions/concerns that may arise post-implementation To learn more, please contact us at . Note: Not available in Restricted Jurisdictions. See [Terms](https://vip.rocksolid.network/terms#tos) for a full list. # Terminology
TermDefintion
DepositorA Depositor is any user who contributes assets into a RockSolid Vault. Depositors receive Receipt Tokens that represent their share of the Vault and entitle them to withdraw their assets and any rewards earned.
DistributorRockSolid is the Distributor. The Distributor works with the Partner Protocol to ensure the vault is configured to match its objectives, including risk appetite, asset type, and reward structure. The Distributor provides front-end integration and distributes the vault via its own front-end.
High-Water MarkA fee safeguard: rewards fees are only collected on new gains above the vault’s previous peak NAV, ensuring depositors don’t pay fees twice for the same performance.
Looping / CompoundingA strategy where assets are deposited, used as collateral to borrow more, and redeposited to amplify rewards. Rewards earned are automatically reinvested, compounding returns over time.
MPC (Multi-Party Computation) WalletsCryptographic wallets controlled by multiple independent parties. RockSolid uses MPC wallets to enforce operational security (e.g., withdrawals, parameter updates, whitelisted strategies) without relying on a single key holder. Multiple signers are required to process transactions.
NAV (Net Asset Value)The total value of assets held by the vault. NAV is updated via a two-step asynchronous process and used to determine the fair value of deposits and withdrawals.
OraclesRockSolid uses external data feeds (e.g., Pyth) for display purposes. NAV updates rely on a two-party manual process: 1) Proposal by Strategy Manager and 2) Accept/Reject by the Distributor. All updates are viewable on-chain (e.g., via Etherscan).
Partner ProtocolPartner Protocols are external projects, asset issuers, or asset owners that RockSolid integrates with to create Vaults.
Example: Rocket Pool
Pending Rewards (Unrealized Rewards)Rewards that are accruing but not yet realized or reflected in NAV. Example: points or tokens accumulating in a campaign but released later. Withdrawals before realization forfeit pending rewards.
Points / Incentive RewardsIncentives distributed by underlying DeFi protocols that accrue to vault depositors. May remain pending before being realized.
Receipt Token (aka Vault Shares)A Receipt Token is received when depositing into a RockSolid vault. It represents your share of the vault (deposit + rewards). Required for withdrawals.
Example: rock.rETH for the Rocket Pool rETH Vault.
Redemption QueueThe system for managing asynchronous withdrawals, batching user requests into the next withdrawal window (typically 24h).
Reference AssetThe token deployed inside the vault (e.g., ETH, USDC, rETH). All rewards are denominated in this asset and returned in this asset on withdrawal (regardless of the asset deposited).
Rewards FeeA percentage of rewards, accrued as newly minted shares to the fee receiver during NAV updates. Applied only when vault value exceeds its previous peak.
Service FeeA baseline fee on vault TVL, accrued daily as newly minted shares to the fee receiver whenever NAV is updated.
StrategyA defined set of actions the Strategy Manager uses to generate rewards on Vault Assets. Can include lending, staking, liquidity provision, or incentive farming within risk limits.
Strategy Manager (aka Strategist, aka Curator)An entity responsible for proposing, executing, and monitoring vault strategies. Only whitelisted strategies can be executed.
Example: Tulipa Capital for the Rocket Pool rETH Vault.
TVL (Total Value Locked)The total dollar value of assets deposited in a vault. A key metric for scale, adoption, and fee accrual.
VaultA smart contract that accepts deposits of a reference asset and allocates them into DeFi strategies. Depositors receive vault shares representing ownership.
WhitelistA pre-approved list of strategies or counterparties eligible for execution. Proposed by the Strategy Manager and approved by the Distributor (and sometimes the Partner Protocol).
Withdrawals (Asynchronous)A withdrawal mechanism where users cannot instantly withdraw. Requests are processed every ~24H (ERC-7540 standard). Protects against instant draining during mispricing, depegs, or oracle failures.
# Architecture & Roles ## Architecture A **vault** is a smart contract that accepts deposits of a reference asset and allocates them into DeFi strategies. Depositors receive vault shares that represent their ownership. As the vault’s value changes, so does each user’s share. Vaults are denominated in a **reference asset**, most commonly ETH-based assets such as rETH. In the case of the Rocket Pool rETH vault, other supported assets which can be deposited (ETH, WETH, stETH in this case) are automatically swapped into the vault’s reference asset via routing to a decentralized exchange.
## Roles Vaults consist of multiple interacting roles and systems that ensure assets are deployed effectively while minimizing operational and security risks. Below is a walkthrough using the **rETH Vault** as an example.
### User / Depositor Depositors supply the reference asset to the vault and receive receipt tokens representing their proportional share. The flow for a typical depositor is: 1. A user deposits rETH into the vault. 2. The vault mints and returns a receipt token (ERC-20) representing ownership. 3. While holding the receipt token, depositors can: 1. View how vault assets are allocated. 2. Monitor the changing value of their share. 4. Withdrawals: 1. A user can request a withdrawal from the wallet that is holding their receipt token. Withdrawals will show as ‘pending’ once the withdrawal has been requested. 2. Withdrawals will be received in the reference asset of the vault (regardless of what asset was deposited). e.g. in the case of the Rocket Pool rETH vault, if a user deposits stETH, that asset is converted into rETH and deployed into the vault. If that user withdraws they will receive rETH. 3. Withdrawals are processed every 24 hours. This is a feature of the ERC-7540 Asynchronous Tokenized Vault Standard. 4. After Withdrawal processing, a user can Claim the resulting reference asset.

Details panel showing service fee (1%), reward fee (10%), withdrawal period (~24h), and partner protocols for the rETH vault.

### Strategy Manager (aka Curator, aka Strategist) The Strategy Manager is responsible for proposing and executing strategies that deploy vault assets. They are also responsible for proposing NAV updates. The Strategy Manager cannot unilaterally conduct any transaction that has not already been whitelisted via a multi-party approval process. #### The Strategy process is as follows: 1. Strategy Manager proposes a new strategy via Vault Management Platform 2. Strategy is reviewed and added to the whitelist (or rejected) by the Distributor via MPC (the Partner Protocol can also be part of this process, if desired). 3. Once approved, the Strategy Manager deploys assets, with strict guardrails: 1. Only whitelisted strategies are accessible. 2. Assets can move only to and from pre-approved protocols. 3. All transactions must satisfy signing policy rules. 4. Any transactions that don’t conform to these rulesets are autorejected by the MPC signing solution. #### The NAV update process is as follows: 1. Each day, the Strategy Manager proposes a new vault token price per share based on strategy APR. 2. The Distributor reviews this proposed update, checking against on-chain data, and co-signs approval using the MPC signing solution. #### What a Strategy Manager *can* do: * Deploy assets from the Vault into whitelisted Strategies unilaterally. * Rebalance allocations between approved Strategies to maintain risk/reward targets. * Operate within vault parameters such as position size limits, protocol whitelists, and risk thresholds. * Submit transactions via the institutional-grade MPC wallet for Distributor approval. #### What a Strategy Manager *cannot* do: * Withdraw or transfer assets to non-approved addresses (all flows must remain within the Vault or whitelisted Strategies). * Change the Strategy (e.g., cannot switch from a conservative strategy to a high-risk one without co-signing from the Distributor). * Override withdrawal rights of Depositors (users can always redeem according to Vault terms). * Alter NAV reporting or bypass oracle updates. NAV submissions are reviewed and confirmed independently. [Tulipa Capital](https://www.tulipa.capital/) is the Strategy Manager for the rETH Rocket Pool vault. ### Distributor The Distributor (RockSolid) works with the Partner Protocol to ensure the vault is configured to match its stated objectives, including risk appetite, asset type, and reward structure. The Distributor cannot unilaterally conduct any transaction. \ The Distributor performs the following roles: * Reviews new strategy requests (proposed by the Strategy Manager) against the vault’s mandate and objectives. * Ensures allocations remain consistent with the vault’s design. * Acts as cosigner on admin functions and whitelist proposals. * Acts as cosigner on daily NAV updates. ### Vault Management Platform The Vault Management Platform provides the underlying infrastructure that powers RockSolid Vaults. It is a set of battle tested, audited smart contracts that standardize how deposits, withdrawals, accounting, NAV updates, and contract upgrades are handled, ensuring that Vault Strategies can be deployed safely, transparently, and at scale. [Lagoon](https://app.lagoon.finance/) is the Vault Management Platform in the case of the rETH vault. ### MPC Signing Solution The Signing Solution enforces the policies and controls of the vault. For example it controls the creation and approval of whitelisted strategies, ensuring that vault assets can only be deployed into pre-approved protocols. Actions that are not pre-approved are automatically rejected by the signing solution. All operational asset deployment transactions require multi-party computation signing workflows, split between the Distributor and the Strategy Manager. The Partner Protocol can also be involved in these approval flows if desired. [Fordefi](https://fordefi.com/) is the Signing Solution in the case of the rETH vault. ### Partner Protocol A Partner Protocol is an external project or asset issuer that RockSolid integrates with. Partner Protocols may be the asset issuer of the Vault Asset(s) or an entity who otherwise controls the Vault Assets (for example, a wallet holding balances of various ERC20 tokens). Partner Protocols are also central in establishing the Strategy of their respective Vaults. [Rocket Pool](https://rocketpool.net/) is the Partner Protocol in the case of the rETH Vault. ### Security Council The Security Council is only called upon in exceptional circumstances (e.g. where one of either the Distributor or Strategy Manager becomes unreachable or acts maliciously, which thus prevents the MPC signing quorum from being reached). In such a circumstance, a majority of the Security Council are able to join with the remaining party to enable an admin policy change in the MPC solution that replaces the other party, to allow an orderly transition to a new Distributor, Strategy Manager, or wind-down of a vault. The Security Council currently consists of crypto-native founders/experts from well-known teams, with many years of DeFi experience between them. For security reasons their identities are kept private. # Technology RockSolid Vaults are built on a stack of standards-compliant contracts and institutional-grade MPC systems. **Smart Contracts** * All vaults are deployed as[ ERC-7540](https://eips.ethereum.org/EIPS/eip-7540) contracts, an asynchronous extension of [ERC-4626](https://ethereum.org/developers/docs/standards/tokens/erc-4626/). * ERC-7540 allows vaults to handle deposits and withdrawals asynchronously, which is essential for strategies that rely on staking or queue-based redemptions. * The Rocket Pool rETH vault deploys the smart contracts built by [Lagoon Finance](https://app.lagoon.finance/), independently [audited](https://docs.lagoon.finance/resources/audits) by Nethermind. These contracts are live and secure >$140m in TVL **MPC and Multisig Wallets** RockSolid Vaults support both Safe Multisig and MPC custody solutions, such as Fireblocks and Fordefi. Transaction controls include: * Role-based approvals (separating Strategy Manager, Distributor, and Partner Protocol). * Threshold signing for large transactions. * Whitelisting to ensure assets are only deployed into pre-approved strategies (any other transaction will be auto rejected) The Rocket Pool rETH vault uses [Fordefi](https://fordefi.com/) as the MPC solution. #### Oracles and NAV * Unlike most vaults, RockSolid calculates NAV manually at regular intervals. This avoids sole reliance on oracles, reduces exposure to gaming of deposit/withdrawals, and ensures accuracy for incentive rewards that accrue over time. All NAV updates are viewable on chain (e.g via Etherscan). * This is a two-step process by which the Strategy Manager proposes an NAV update, and the Distributor co-signs and approves that update. * This reduces exposure to oracle manipulation and ensures accuracy across strategies with delayed reward realization (e.g., incentive lockups). * RockSolid uses external data feeds like Pyth for display purposes (e.g., showing rETH values). #### Monitoring and Controls * Continuous monitoring of vault positions, strategy health, and counterparty exposure. * Exposure caps are enforced per vault and per strategy, limiting the systemic impact of experimental or high-risk allocations. # Integration Integration with RockSolid is a straightforward process. The steps involved depend on the style of integration: 1. Link only 2. White label / 'Powered by' 3. Fully Hosted **Link only** Each RockSolid vault comes with a url. For example the RockSolid rETH Vault is accessible at All functionality, such as deposit, withdraw and view holdings are available there. **White label / Powered by** RockSolid vaults are designed to be fully integrated into your front-end, such as a liquid staking protocol or a centralized exchange "earn" product. This let's users stay in your website or app with the familiar UI, but still get all the benefits of a RockSolid vault. See the [Rocket Pool integration](https://stake.rocketpool.net/rocksolid/vault/deposit) for an example. You will interact with our [Smart Contracts](/integration/smart-contracts) and [API](/integration/api) for this style of integration. **Fully Hosted** The entire RockSolid app can be themed and hosted by RockSolid, but accessed from your domain. For example, **.** Contact us at for more information. # Onboarding Guide ## General Timeline * Week 1: * Vault design and mandate agreed * Smart contracts deployed * RockSolid front-end and app live * Week 2: * Partner integration underway or complete * Weeks 3-4: * Predeposits received from partners, LPs, and/or whales and deployed into DeFi * Public launch, marketing and GTM campaign finalized ## Key Steps Required for Launch ### 1. Decide integration locations (any combo of the below): * RockSolid website and app * Your website and app * Custom integration (e.g. into a wallet or exchange) The deployment of the smart contracts and integration to the RockSolid website and app can occur within a day. Integration with your website/app or a custom integration may take longer. RockSolid devs can handle as much or as little of the integration work you prefer. ### 2. Vault design Decisions must be made upon each of these dimensions with your team before deploying. RockSolid is able to suggest default values for each of these decisions: * Token symbol and name * Vault name and description * Vault logo * Do you want the vault to be public or private? * Deposit asset (e.g. ETH, USDC, etc.) and on what network? * Fee structure (management and performance fee) * Strategy mandate (strategies, APR target, leverage, diversification requirements, etc) ### 3. Go-to-Market * Secure pre-deposits from LPs / whales * Prepare launch comms and marketing assets * Secure podcasts / interviews / etc to coincide with launch # Smart Contracts RockSolid vaults build upon the Lagoon ERC7540 Asynchronous Vault implementations. As such, these [docs](https://docs.lagoon.finance/developer-hub/integration) equally apply to RockSolid. ## Quick Start Guide You can see all the [read](https://etherscan.io/address/0x936facdf10c8c36294e7b9d28345255539d81bc7#readProxyContract) and [write](https://etherscan.io/address/0x936facdf10c8c36294e7b9d28345255539d81bc7#writeProxyContract) functions on etherscan. ### Deposit ```solidity function syncDeposit(uint256 assets, address receiver, address referral) payable returns (uint256 shares); ```
ParameterValue
assetsThe amount of assets to deposit, in wei
receiverThe recipient, usually the connected wallet
referralReferrer if you are running a referral program or 0x0000000000000000000000000000000000000000 if not or there is no referrer
### Withdraw Withdrawal is two step. 1) You **request to redeem** and approximately 24 hours after processing 2) redeem ```solidity function requestRedeem(uint256 shares, address receiver, address controller) ```
ParameterValue
shares The amount of shares to redeem, retrievable from vault.balanceOf(address)
receiverThe recipient of the shares. Should be depositor unless this is a custodian integration.
controllerShould be the depositor, unless this is a custodian integration.
```solidity function redeem(uint256 shares, address receiver, address controller) ```
ParamterValue
sharesThe amount of shares to redeem. Should be the same value supplied to requestRedeem()
receiverThe recipient of the shares. Should be the deposior unless this is a custodian integration.
controllerShould be the depositor, unless this is a custodian integration.
### View Balance The number of shares a user address owns is available via: ```solidity vault.balanceOf(userAddress) + vault.pendingRedeemRequest(0, userAddress); → user shares waiting to be redeemed ``` ### Utility Functions Standard ERC20 and ERC4626 functions that are helpful during integration include ```solidity convertToAssets(uint256 shares) → how much asset (e.g. rETH) per share convertToShares(uint256 assets) → how many shares (e.g. rock.rETH) per asset totalAssets() → total assets in the vault, aka TVL totalSupply() → total shares in the vault. symbol() → name of the share e.g. rock.rETH name() → name of the vault e.g. RockSolid rETH Vault safe() → address of the controlling wallet. May be a Safe or MPC. ``` # API ## RockSolid Vault API Documentation **API Version:** v1\ **Last Updated:** September 11, 2025\ **Status:** Active This document describes the RESTful API endpoints for the RockSolid Vaults API. ### Base URL All API endpoints are relative to `https://app-integration.rocksolid.network/api/` #### Allowed Origins Current CORS whitelist includes: * `*.rocketpool.net` * `*.rocksolid.network` * `http://localhost:3000` (development) * `http://localhost:8788` (Wrangler dev) * `http://localhost:8787` (Wrangler dev alternate) *** ### GET /api/vaults Returns comprehensive information for all available vaults including metadata, performance data, strategy allocations, and curator information. This endpoint provides the same rich data structure as the individual vault endpoint but optimized for batch operations. Response: ```typescript VaultDataResponse[] ``` Where `VaultDataResponse` includes: ```typescript // Complete vault metadata structure { vault_id: number; name: string; symbol: string; // ... (see individual vault endpoint for full structure) } ``` * Complete vault metadata (name, symbol, description, addresses, fees, etc.) * `is_active`: boolean field controlling vault visibility * Curators array with many-to-many relationship support * Rewards array with additional reward information (see Reward object structure in individual vault endpoint) * Chain information with blockchain network details * Underlying asset information with token metadata and price feeds * Latest performance data (per\_share\_nav, outstanding\_shares, estimated\_apr) * Strategy allocations with percentages and APR data * Performance history (limited to 5 records for optimization) Data Structure: Each vault object in the response array has the same structure as the individual vault endpoint response (see `GET /api/vaults/{vault_address}` for detailed field descriptions). To filter only active vaults: ```typescript const activeVaults = vaults.filter((vault) => vault.is_active); ``` Error Responses: * `500`: Server error *** ### GET /api/vaults/{vault\_address} Returns detailed information for a specific vault identified by its contract address. Parameters: * `vault_address` (path): Vault contract address (string) Response: ```typescript VaultDataResponse; ``` See type definition in `/src/lib/types/vault.ts`. Includes: * Complete vault metadata * `is_active`: boolean field controlling vault visibility * Curators array with many-to-many relationship support * Rewards array with additional reward token information * Chain information with blockchain network details * Underlying asset information with token metadata and price feeds * Latest performance data * Strategy allocations with percentages * Performance history (last 30 records) Error Responses: * `404`: Vault not found * `500`: Server error Example Response Structure: ```json { "vault_id": 1, "name": "Balanced rETH Vault", "symbol": "brETH", "description": "A diversified vault for rETH holders", "is_active": true, "vault_address": "0x56bf650cfb09396dc1ee845b0049d839b2b7d854", "chainId": 8453, "priority": 100, "curators": [ { "curator_id": 1, "name": "Tulipa", "logo_url": "https://example.com/tulipa-logo.png" } ], "rewards": [ { "reward_id": 1, "name": "Morpho", "logo": "https://example.com/morpho-logo.png", "classification": "Token", "is_active": true }, { "reward_id": 2, "name": "Beefy", "logo": "https://example.com/beefy-logo.png", "classification": "Points", "is_active": true } ], "platform": { "platform_id": 1, "name": "Base", "logo_url": "https://example.com/base-logo.png" }, "chain": { "chain_database_id": 1, "chain_id": 8453, "name": "Base", "logo_url": "https://basescan.org/assets/base/images/svg/logos/chain-light.svg", "explorer_url": "https://basescan.org" }, "underlying_asset": { "token_id": 2, "symbol": "rETH", "name": "Rocket Pool ETH", "icon": "/logos/r-eth.svg", "address": "0xae78736cd615f374d3085123a210448e74fc6393", "decimals": 18, "price_feed_id": "0x52f9f30dceaba7cca1e54cec3bb4024e8c471307", "price_feed_token": "ETH", "is_active": true, "chain_database_id": 1 }, "performance_history": [...], "allocations": [...] } ``` Reward Object Structure: The `rewards` array contains Reward objects with the following structure: ```typescript interface Reward { reward_id: number; // Unique reward identifier name: string; // Reward name (e.g., "Arbitrum", "Optimism") logo: string; // URL to reward token logo image classification: string; // Type of reward ("Token", "Points", "NFT") is_active: boolean; // Whether reward is currently active } ``` Note: Only active rewards (`is_active: true`) are returned in API responses. Caching: 5 minutes (300 seconds) *** ### GET /api/vaults/{vault\_address}/allocations Returns allocation snapshots for a specific vault and allocation period, including optional performance notes. Parameters: * `vault_address` (path): Vault contract address (string) * `period-id` (query): Allocation period ID (integer, required) Response: ```typescript GetAllocationSnapshotsResponse; ``` See type definition in `/src/lib/types/vault.ts`. The response structure includes: ```typescript { snapshots: AllocationSnapshot[]; performance_note?: PerformanceNote; } ``` AllocationSnapshot Structure: Each allocation snapshot includes: * `id`: string (allocation ID) * `strategy`: string (strategy name) * `description`: string (strategy position) * `logoUrl`: string | undefined (strategy logo) * `allocation`: number (percentage as decimal, e.g., 0.20 = 20%) * `strategyApr`: number (APR as decimal, e.g., 0.05 = 5%) * `ongoingApr`: number | null (ongoing APR as decimal) * `pendingApr`: number | null (pending APR as decimal) * `totalApr`: number (total APR as decimal) PerformanceNote Structure (optional): If a performance note exists for the vault and allocation period: * `vault_performance_note_id`: number (note ID) * `title`: string (note title) * `content`: string (note content/description) * `url`: string | undefined (optional URL reference) Data Transformations: * Allocation percentages are converted from basis points to decimals (stored value ÷ 100) * APR values are converted from basis points to decimals (stored value ÷ 100) * Returns empty snapshots array if vault has no allocations * Performance note is undefined if no note exists for this vault/period combination Example Response (with performance note): ```json { "snapshots": [ { "id": "25", "strategy": "Aave USDC Lending", "description": "Long", "logoUrl": "https://example.com/aave-logo.png", "allocation": 0.455, "strategyApr": 0.0525, "ongoingApr": 0.0525, "pendingApr": null, "totalApr": 0.0525 }, { "id": "26", "strategy": "Compound ETH Lending", "description": "Long", "logoUrl": "https://example.com/compound-logo.png", "allocation": 0.545, "strategyApr": 0.048, "ongoingApr": 0.048, "pendingApr": 0.012, "totalApr": 0.06 } ], "performance_note": { "vault_performance_note_id": 1, "title": "Q3 2025 Performance Update", "content": "Strong performance driven by increased lending rates on Aave and successful strategy rebalancing. ETH positions benefited from market volatility.", "url": "https://docs.rocksolid.network/performance/q3-2025" } } ``` Example Response (without performance note): ```json { "snapshots": [ { "id": "27", "strategy": "Uniswap ETH/USDC LP", "description": "Long", "allocation": 1.0, "strategyApr": 0.035, "ongoingApr": 0.035, "pendingApr": null, "totalApr": 0.035 } ] } ``` Error Responses: * `400`: Missing or invalid period-id parameter * `404`: Vault or allocation period not found * `500`: Server error Caching: 5 minutes (300 seconds) with custom Cache-Control headers (`s-maxage=300, stale-while-revalidate=300`) *** ### GET /api/vaults/allocation-periods Returns all available allocation periods for use in date selectors and period navigation. Response: ```typescript GetAllocationPeriodsResponse; ``` Structure: ```typescript { periods: AllocationPeriodItem[]; total: number; } ``` Where `AllocationPeriodItem` includes: * `allocation_period_id`: number * `period_start`: Date (Unix timestamp) * `period_end`: Date (Unix timestamp) Data Ordering: Results are ordered by `period_start` in descending order (newest first). Error Responses: * `500`: Server error Caching: No explicit caching configured (relies on default Next.js behavior) *** ### GET /api/vaults/{vault\_address}/apr Returns calculated Annual Percentage Rate (APR) and Total Value Locked (TVL) for a specific vault, with enhanced APR calculations for rETH vaults. Parameters: * `vault_address` (path): Vault contract address (string, automatically normalized to lowercase) * `days_to_compute` (query, optional): Number of days to use for APR calculation (integer, default: 14, must be positive) Response: ```typescript { tvlRaw: string; // Total value locked in wei (string to prevent precision loss and serialization issues) apr: string; // APR as percentage string against underlying asset (e.g., "12.34") baseAprAgainstEth: string; // Base APR against ETH for rETH vaults (e.g., "3.45") strategyAprAgainstEth: string; // Strategy APR against ETH for rETH vaults (e.g., "8.89") totalAprAgainstEth: string; // Total APR against ETH for rETH vaults (e.g., "12.34") } ``` Usage: This endpoint combines subgraph event data with Lagoon Protocol SDK calculations to provide accurate performance metrics. APR calculation adapts based on vault maturity (inception APR for vaults <30 days, historical calculation for mature vaults). Enhanced rETH APR Calculations: For rETH vaults, the endpoint provides additional APR breakdowns against ETH to show the relative performance compared to holding ETH directly. Implementation Details: * Vault address is automatically normalized to lowercase * Chain ID is automatically determined from the vault's database record (no longer needs to be provided) * Uses GraphQL subgraph queries to fetch vault events * Integrates rETH-specific APR calculations via `getRethAprCalculation` * Error responses include detailed error messages for debugging Error Responses: * `400`: Invalid days\_to\_compute parameter (not a positive integer) * `404`: Vault not found * `500`: Subgraph query failed, no events found for vault address, or server error Caching: 5 minutes (300 seconds) *** #### Error Response Format Most endpoints return errors in this format: ```typescript { error: string; // Brief error description message: string; // Detailed error message } ``` # Price Data Feed This section describes how to derive the price of rock.rETH shares. ## tldr; You can get the **rock.rETH:ETH** exchange rate here: ## Overview The price of a vault share represents the value of the underlying asset the share is a claim on. ### USD For example if 1 **rock.rETH** share is worth 1.05 **rETH** and rETH/USD = $5,000 **USD**, then 1 rock.rETH = 1.05 x $5,000 = $5,250. Conversely that means 1 **rETH** = 0.95238 **rock.rETH** (1/1.05). ### ETH Similarly for ETH, if 1 **rock.rETH** share is worth 1.05 rETH and 1 **rETH** = 1.1443 **ETH** then 1 rock.rETH = 1.05 x 1.1443 = 1.201515 ETH ## Integration For integration with RockSolid vaults, there are a number of ways to source pricing, both on-chain and via API. ### On-chain #### Rate Provider The simplest way to calculate **rock.rETH** exchange rates is to use the Balancer rate provider deployed [here](https://etherscan.io/address/0x716f0c5453099690b54e7b72d9491a72b8df445e#readContract#F1). That returns the **rock.rETH:ETH** exchange rate in wei. For example, at the time of writing it is 1161699563412314198 which when [converted](https://etherscan.io/unitconverter?wei=1161699563412314198) to ETH is 1.16. I.e. 1 rock.rETH = 1.16 ETH. For display, you would source ETH/USD from your preferred provider #### ERC-4626 style calculation To obtain the value 1 rock.rETH share in the underlying asset rETH purely from the smart contract, you can use standard ERC-4626 methods. You convert an amount of shares to assets and divide by the scale of the underlying. To obtain rock.rETH to rETH it would be: * `convertToAssets(10 ** vault.decimals()) / 10 ** underlyingAsset.decimals()` For USD, simply multiple by the rETH/USD exchange rate ### API We don't currently provide exchange rates via API. Please reach out at [product@rocksolid.network](mailto:undefined) if you need this. # rETH Vault The rETH vault is our flagship vault, deployed in collaboration with the Rocket Pool protocol. Depositors can access it directly from Rocket Pool at: \ or from the RockSolid app at:\ [https://app.rocksolid.network/vaults/reth-vault](https://app.rocksolid.network/vaults/0x936facdf10c8c36294e7b9d28345255539d81bc7) FYI - The above links will be broken until the public launch announcement
ItemDescription
Receipt tokenrock.rETH
Vault assetrETH
Vault addressreth.vaults.rocksolidnetwork.eth / 0x936facdf10c8c36294e7b9d28345255539d81bc7
ChainEthereum mainnet
ObjectiveTargets up to 6%* APR with preference for the best risk adjusted rewards, and a goal to also be net beneficial to the Rocket Pool protocol.

*APR is variable and not guaranteed.
DistributorRockSolid
Strategy ManagerTulipa
Vault PlatformLagoon
Signing SolutionFordefi
DepositsInstant
WithdrawalsProcessed approximately every 24 hours
# AutoPlus Looped ETH Vault The RockSolid AutoPlus Looped ETH Vault is our flagship looping vault, deployed in collaboration with Pier Two. The vault incorporates a dedicated Lido v3 deployment supported by Pier Two’s non-custodial validator infrastructure. Depositors can access it from the RockSolid app at:
ItemDescription
Receipt tokenrock.loopedETH
Vault assetWETH
Vault address0x7a12d4b719f5aa479ecd60defed909fb2a37e428
ChainEthereum mainnet
Objective

Targets up to 6%* APR,using 5-6x leverage. The vault’s current strategy is leveraged looping of stETH using Lido v3 infrastructure.

*APR is variable and not guaranteed.

DistributorRockSolid
Node OperatorPier Two
Strategy ManagerTulipa
Vault PlatformLagoon
Signing SolutionFordefi
DepositsInstant
WithdrawalsProcessed approximately every 24 hours
# MegaETH USDm Vault The RockSolid MegaETH USDm Vault utilizes USDm to access DeFi yields in the MegaETH ecosystem. The vault mints USDm from USDC deposits on Ethereum and deploys the USDm into MegaETH ecosystem projects. The yield is derived from a combination of MegaETH DeFi yield plus MegaETH points. The vault targets to earn 5% yield. Depositors can access it from the RockSolid app at:
ItemDescription
Receipt tokenrockUSDm
Vault assetUSDC
Vault address0xBa71097E426983D840569EdFa1a01396b56D86Ad
ChainEthereum mainnet
Objective

Targets 5%* APR by deploying USDm into the MegaETH DeFi ecosystem.

*APR is variable and not guaranteed.

DistributorRockSolid
Strategy ManagerTulipa
Vault PlatformLagoon
Signing SolutionFordefi
DepositsInstant
WithdrawalsProcessed approximately every 48-72 hours
# Staking Liquidity Vaults (Lido V3) ## Summary RockSolid Staking Liquidity vaults offer ETH holders the ability to stake ETH (to generate a return) with their chosen operator (for security, compliance and performance) while retaining the ability to instantly access liquidity, regardless of the state of the Ethereum exit queue. It is a significant evolution in the value proposition of staking for institutional holders of ETH. ## Introduction ETH staking offers ETH holders a way to generate a return on their assets. However, it has always come with an uncomfortable trade-off: #### Native staking * ✅ Choice of operator (jurisdiction, client diversity policies etc.) * ✅ Negotiable fees * ✅ No clear exchange of assets, which may be better from a tax perspective * ❌ Illiquid due to a variable exit queue, sometimes as high as 40+days (see [current queue](https://tools.rocksolid.network/validator-queue)) #### Liquid staking * ✅ Liquid: can swap stETH for ETH, although sometimes with a haircut * ✅ Liquid: can redeem stETH for ETH from the protocol, although with a delay * ❌ No choice of operator * ❌ Non-negotiable fees (10% for Lido) * ❌ Immediate exchange of ETH for the LST, which may trigger a taxable event depending on jurisdiction. ### Lido V3 stVaults Lido V3 aims to solve this problem by offering ETH holders the ability to stake with their chosen operator (benefits of native staking) while still being able to **access liquidity on demand,** by being able to mint **stETH** against natively staked ETH on validators as collateral. ## The Problem Lido V3 is a powerful primitive, but it's not a packaged solution to the problem of staking with a node operator with guaranteed liquidity. Setting up an stVault today would require * Deploying at stVault from the Lido stVault factory, requiring familiarity with interacting with smart contracts (example [transaction](https://etherscan.io/tx/0xd0b94a3e17722d7cf3249584b502307ac7a5245aed43a68bface5bbaee6a54d7)) * This includes defining the vault administrator, node operator, node operator manager and vault roles. * Most node operators are experts in staking operations, but not smart contracts or vault operations * Most ETH stakers are experts in digital assets, but not smart contracts or vault operations * Configuring the vault * By default, Lido stVaults allow minting up to 50% stETH against the staked collateral. Increasing this requires Lido DAO application and smart contract calls on the node operator and vault admin side * Creating validators * When an ETH staker supplies ETH to an stVault, it sits in the contract until it's deposited to a beacon chain validator * That requires the public key of the created validator(s) and a mechanism for creating. * Either the node operator is creating validators and registering them with smart contracts, or the ETH holder is (typically neither role is comfortable with that) * Topping up validators * Topping up requires a strategy for how to "spread" the ETH around validators, e.g. maxxing out a MaxEB validator to 2048 ETH before creating another, or limiting to 32 ETH only (not recommend) or some arbitrary limit, such as 1,000 ETH per validator * Partial withdrawals and exits * This requires a strategy for which validator to partial withdraw from first and when to exit. All of these problems are solvable by either the node operator or ETH staker, but they are essentially "vault operations" which are better undertaken by professional vault operators. ## The Solution RockSolid Staking Liquidity Vaults wrap up the Lido V3 primitive into an e2e managed platform whereby: #### For ETH Holders / Stakers Stakers receive a dedicated vault UI with preconfigured vault including the chosen node operator and validator strategy. The onboarding is "white glove" including training. From that point an ETH Staker can: * Deposit ETH to the vault and it will be instantly and automatically staked with the node operator * Fees and performance are as per native staking (see Fees below) * At any time, the ETH staker may **mint stETH** against the natively staked ETH to meet short term liquidity needs. This could be: * A DAT or fund meeting redemptions * A fund requiring short term liquidity for an acquisition (swap stETH for USDC) * A fund desiring a mix of staking rewards and stETH to deploy into higher yield DeFi #### For Node Operators Node operators are able to solve the difficult problem of "native staking"; guaranteed and instant liquidity, helping both retention for existing clients and unblocking sales to customers previously uncomfortable with unpredictable exit queues. "Going it alone" requires skilling up operational teams to create, configure and advise customers on the operation of stVault smart contracts, including helping customers with validator creation, topups, withdrawals and exits. **RockSolid Staking Liquidity Vaults are an e2e solution to offering native staking with guaranteed liquidity.** ## How it works * RockSolid onboards a node operator by integrating their API * Node operator sells the solution to their customer (the ETH staker) * RockSolid deploys a per-customer Lido V3 stVault and configures to use the node operator as the staking destination, including fees using the RockSolid API and management tools * RockSolid provides a dedicated vault page for the ETH staker to access their vault * The ETH staker deposits/supplies ETH to the vault * The RockSolid Vault Keeper gets notified of new deposits and: * Looks up the ETH staking straetegy (usually "MaxEB" whereby a 0x2 validator is created and topped up until 2048 ETH, and then another is created) * This is using the pre-integrated node operator API * ETH is now staked with the node operator and earns staking rewards the same as it if it were natively staked (see [Fees](#fees)) * If the ETH staker has need for liquidity, they can mint stETH between 50-95% of the value of the ETH staked. They can use the stETH as-is, or convert it to ETH or USDC using the deep stETH liquidity * While the stETH is "borrowed" from the vault, it is recorded as a liability and grows at the same rate as stETH (e.g. 2.7%) * When the short term liquidity needs have passed, the ETH staker can repay the stETH at any time. * If the ETH staker wants to withdraw ETH from the validators, they simply go to the "Partial withdraw" section of the UI and can withdraw any ETH between 32-2048 ETH on any validator. * Partial withdrawals are taken per the "unstaking strategy" configured at setup time, e.g. from highest balance first * If more is required, they can trigger exits directly from the UI * Other house keeping tasks for Lido stVault operation, such as the daily updating of vault balances required by the protocol, are handled by the RockSolid keeper. ### Non-custodial One nice feature of the Lido V3 architecture is that deposits to the stVault are to a non-custodial smart contract. Additionally, ETH sent to the node operator's validators are controlled by the stVault smart contract, so the ETH staker, not the node operator retains ultimate control of the assets. ## Architecture
## Fees * **Lido V3 protocol fees** * Infrastructure fee (% of staking rewards for any ETH staked on validators). This is **0%** at the time of writing for vaults with 250+ ETH as a campaign targeting the long Ethereum validator entry queue * Liqudity fee (% of the minted stETH, calculated as stETH liability x Lido Core APR x liquidity fee %). This is **6.5%** at the time of writing * **Node operator fees** * As negotiated with your node operator, typically the same as for native staking * **RockSoldi fees** * As negotiated with RockSolid, typically a percentage of staking rewards. # How to Deposit ### Introduction This guide explains how to deposit into RockSolid Vaults for the first time. The steps are designed to be simple, transparent, and repeatable. ⚠️ **Important**: Do not send assets directly to a vault contract. Deposits must always be made through the the app. ### Step-by-Step: #### Step 1: Connect Wallet * Supported wallets: MetaMask, Coinbase Wallet, WalletConnect, Ledger, and [500+ more](https://portal.thirdweb.com/wallets/external-wallets)

Connect your wallet (MetaMask, Coinbase Wallet, WalletConnect, etc.) on Ethereum Mainnet to begin your deposit.

**Step 2: Select a Supported Asset** * Supported assets for the Rocket Pool vault: ETH, rETH, stETH, WETH * If you deposit ETH, stETH, or WETH, the vault routes through 0x to convert into rETH. * This routing is a convenience only. It does not guarantee best execution.
Choose a supported asset. Non-rETH tokens are swapped into rETH
*⚠️ **Note on Slippage:** Max slippage is automatically set to 1%. If slippage is higher, the transaction fails. For large deposits, swap to rETH directly (e.g., via minting on Rocket Pool or a swapping via a DEX).*
**Step 3: Enter Deposit Amount & Confirm** * Enter the amount.
Review your deposit amount, rETH received, and slippage to confirm
* Confirm transactions in your wallet. Depending on prior approvals, you may see: * Approve 0x to spend your token. * Approve swap venue. * Execute swap.
Confirm the swap in your wallet
Execute the swap
Pop-Up upon successful swap
* Approve vault to spend rETH.
Confirm token approval in your wallet
* Execute deposit.
Approve tokens for the vault
* Once complete, you receive vault shares as ERC-20 receipt tokens representing your ownership in the vault.

Pop-Up upon successful deposit

**Step 4: Manage Your Receipt Token** * Your receipt token = proof of ownership. * Rewards auto-compound, increasing your vault share balance.
Example confirmation screen showing a completed deposit
*⚠️ **If you lose your receipt token, withdrawals are impossible.*** ### Troubleshooting & Notes * If deposit transaction fails, check: * You are on Ethereum Mainnet. * Gas fees are set high enough. * Slippage is not exceeding 1%. * Large deposits: swap directly to rETH before depositing. # How to Withdraw ### Introduction Withdrawing from a **RockSolid Vault** allows you to redeem your deposited assets plus rewards. Withdrawals are processed on a **24-72 hourly cycle,** depending on the vault, to ensure fairness and efficiency. ⚠️ **Important:** You must hold your **receipt token** to withdraw. Without it, assets cannot be redeemed. ### Step-by-Step Guide #### Step 1: Connect Wallet * Supported wallets: MetaMask, Coinbase Wallet, WalletConnect, Ledger, and [500+ more](https://portal.thirdweb.com/wallets/external-wallets)

Connect your wallet (MetaMask, Coinbase Wallet, WalletConnect, etc.) on Ethereum Mainnet to begin your deposit.

**Step 2: Navigate to Withdraw Tab** * Select the vault and open the Withdraw tab. **Step 3: Enter Withdrawal Amount** * Enter the number of receipt tokens you wish to redeem.
Withdraw tab where users can initiate a withdrawal
Example wallet confirmation for initiating the withdrawal
**Step 4: Pending Withdrawal Queue** * Request enters the next withdrawal batch cycle. * Withdrawals are processed approximately every 24h-72h.
Confirmation of the withdrawal being initiated

Track the status of your withdrawal under 'My Holdings' section

#### Step 5: **Receive Assets** * After batch processing, assets are released in the vault’s reference asset, such as rETH. ### Troubleshooting & Notes * Withdrawals are **not instant**; they process approximately every 24-72h. * If a withdrawal fails: * Check gas fees. * Ensure you still hold your receipt tokens. ⚠️ Withdrawing early from campaigns with locked rewards forfeits pending APR. # Strategies ### Strategy Reports Reports detailing the vault's allocations to specific strategies will be updated weekly, including their Ongoing and Pending APR contributions. These can be found on the [vault web UI.](https://app.rocksolid.network/) Additionally, look for the “Debank” and “Zerion” links on the vault details page to view onchain positions at any given time.\ \ ![](/files/Z0Iqj11os8GrJ0m2yah2) ### Strategies Overview Strategies are the techniques strategy managers employ to generate returns on the assets deposited in the vault. They are varied and dynamic, evolving in response to new innovations in DeFi, new chains and capital flows. Partner Protocols can specifically include or exclude strategies they prefer; or leave the strategy selection to the Strategy Manager Below are some examples of strategies to give an idea of some of the common ones a Strategy Manager may employ. ### Example Strategies **Leveraged Looping** Especially popular for ETH or LSTs, leveraged looping involves depositing the asset on a lending platform such as Aave, minting an LST (which generates a return), depositing that LST in the lending protocol, to then borrow more ETH, to then mint more of the LST until the health factor of the loans approaches the risk threshold of the vault. * *Pros: Delta neutral if borrowing is in the same asset, such as ETH* * *Cons: Returns can evaporate if borrow rates turn negative; liquidation and capital loss can occur if ETH/LST prices depeg* **Incentive Farming** New chains, or new protocols on existing chains, face a "cold start" problem. Offering incentives for user's to bring assets, such as ETH, to the chain or protocol help provide liquidity, activity and get the "flywheel" started. Because vaults can control large blocks of assets, they may be able to negotiate superior rates for "LP deals" that can be passed on as "alpha" to the vault depositors. * *Pros: Can offer significant returns* * *Cons: Higher risk from new protocols and may involve soft or hard lockups* **Liquidity Provision (LP)** Protocols will often incentivize liquidity providers to provide liquidity for assets. An example is a DEX that is able to offer its users better swap rates for larger volumes the more assets LPs provide. The same protocol may offer additional incentives for "concentrated liquidity". * *Pros: Well understood and sustainable rewards* * *Cons: Requires very active management to avoid impermanent loss* # Rewards ### Introduction All rewards are auto-compounded within the vault. #### Reward Sources * **Base Staking Rewards:** Ethereum staking rewards via LSTs, such as RocketPool's rETH * **DeFi Optimizations:** Rewards from lending, or looping strategies. * **Partner Incentives:** Extra APR campaigns, often locked, such as 90-day pre-deposit campaigns #### Reward Mechanics * **Auto-Compounding:** Rewards reinvest automatically. * **Conversion into rETH:** Regardless of source, rewards crystallize into rETH at withdrawal. ### How Rewards Are Displayed Each strategy shows: * **Allocation (%):** Portion of vault capital deployed in that strategy. * **Strategy APR:** Gross APR of that strategy before fees or batching. * **Ongoing APR:** Rewards already realized and compounding into vault NAV. * **Pending APR:** Rewards accruing but not yet crystallized, such as campaign incentives. * **Total APR:** Sum of ongoing + pending APR for that strategy. The **Total Expected APR** at the top aggregates across all strategies. #### Realized vs Pending Rewards * **Ongoing Rewards:** Already distributed and compounding (shown under **Ongoing APR**). These remain even if you withdraw immediately. * **Pending Rewards:** Accruing but not yet vested (shown under **Pending APR**). Withdrawing before vesting forfeits these. *Example:* If you withdraw during a 90-day incentive campaign on day 89, your **pending APR** is lost. ### Fees * **Service Fee (AUM):** 1% annually, applied to TVL. * **Rewards Fee (Performance):** 10% of realized rewards. * **Governance:** Any change requires a 30-day timelock and contract upgrade. ### Troubleshooting & Notes * If your APR looks lower than the headline: check whether part of it is still under **Pending APR**. * APR values update periodically (see **last updated** timestamp in top-right). # Risks & Safety #### Note: This list is not exhaustive; users should conduct their own due diligence before depositing. See the Comprehensive Risk Disclosure in our [Terms of Service.](https://vip.rocksolid.network/terms#tos) ### Introduction RockSolid Vaults are built on smart contracts that have been [audited](https://docs.lagoon.finance/resources/audits) by Nethermind. These contracts currently secure >$140m of TVL. However, all participation in DeFi carries risk. This page outlines the main categories of risk that depositors should understand, along with the measures RockSolid takes to mitigate them. ### Smart Contract Risk All RockSolid vaults use the [ERC-7540](https://eips.ethereum.org/EIPS/eip-7540) Asynchronous Tokenized Vault Standard, (inheriting from OpenZeppelin’s [ERC-4626](https://docs.openzeppelin.com/contracts/5.x/erc4626)) This vault standard is battle tested and as of Sep 15, 2025 is currently securing >$140m of TVL without exploit. #### Risks * Like any software, these contracts may contain bugs or vulnerabilities that could be exploited. * The developer of the vault smart contract could push an upgrade that compromises user funds. * Smart contracts that the vault deploys assets into (e.g. DeFi protocols or L2s) could be compromised. #### Mitigations * Independent [audits](https://docs.lagoon.finance/resources/audits) conducted by leading security firms such as Nethermind. * Battletested-ness: contracts are already ‘in the wild’ securing >$140m of TVL without exploit. * Contract upgrades are ‘opt-in’, meaning that RockSolid and co-signers are given time to review and approve any upgrades (providing protection against malicious upgrades). All accepted upgrades are time-delayed by 30 days, giving depositors time to review even after RockSolid has approved. * Open-source contracts available for community review. * Continuous on-chain monitoring of contract behavior. ### Slashing Risk #### Risk * ETH validators may face penalties if they behave incorrectly or go offline. * These risks are inherent in the underlying LST deployed (e.g. rETH) and aren’t controlled by RockSolid #### Mitigations * RockSolid vaults primarily allocate to diversified liquid staking tokens (e.g., rETH) * These tokens spread validator exposure across a wide operator set, lowering the impact of any single validator event. ### Liquidity Risk #### Risk * Withdrawals are not instant. #### Mitigations * Vaults maintain partial liquidity buffer. * Clear disclosure of withdrawal mechanics and timing (\~24H withdrawals). * In the future, we expect the vault receipt token to have liquidity in secondary markets to allow instant liquidity if needed. ### Market & Strategy Risk #### Risk * Strategies may involve lending, looping, or interacting with other DeFi protocols. * Risks include liquidation, changes in rewards, external protocol failures, depegs, or total loss of deposited assets #### Mitigations * Exposure caps for each strategy. * Preference for established, battle-tested protocols with high TVL. * Continuous monitoring of positions and market conditions. ### Counterparty Risk #### Risks * Vaults have exposure to several parties, including: the Distributor; the Strategy Manager; the Infrastructure Provider; and external protocols (e.g. DeFi protocols, L1s, L2s, etc). * If a counterparty fails, acts maliciously, or is exploited, vault assets could be lost. #### Mitigations * Whitelisting of strategies such that funds can only be deployed into pre-approved protocols. * Institutional-grade MPC signing and controls such that no single party has the power to unilaterally move user funds outside of pre-approved strategies. * Conservative strategy design with limited exposure to any single DeFi counterparty. ### Oracle Risk #### Risk * Most vaults rely on on-chain oracles for pricing and accounting, which can be manipulated or return inaccurate data. * Underlying DeFi positions and assets (e.g. the exchange rate of LSTs) can be manipulated or can fail, resulting in depegs and liquidation of leveraged positions. #### Mitigations * Manual NAV Updates: RockSolid does not use oracles for NAV. Vault NAV is updated manually through a two-step process (proposal by the Strategy Manager, and co-signing by the Distributor), and positions can be independently verified on-chain (e.g., via DeBank). * Oracles for Display Only: Oracles (Pyth) are used solely for display purposes, such as showing values in rETH. They do not affect vault accounting or strategy execution. ### Transparency and Disclosures All APRs, fees, and allocations are reported clearly. Vault dashboards display: * Strategy-level allocations (staking vs lending vs looping vs incentive farming) * Realized vs accruing APR side by side * Regular updates on audits, monitoring, and risk assessments. # Overview for Protocols ### What RockSolid Provides RockSolid Vaults integrate directly into Partner Protocol front ends. We tailor Strategies in collaboration with our Partner Protocols - enhancing reward opportunities for users while fuelling TVL growth for the protocol. RockSolid Vaults provide protocols, custodians, and stablecoin issuers with a ready-to-deploy vault framework that can be embedded into existing UIs, wallets, or custodial platforms. Vaults are implemented as standards-based contracts (ERC-4626/7540) where Partner Protocols define the reference asset, strategy set, and operational parameters. Partners can choose between branded vaults, whitelabel vaults, and/or vaults integrated directly into their native applications. See the integration of RockSolid into the Rocket Pool [website](https://rocketpool.net/) and [staking app](https://stake.rocketpool.net/) for live examples. RockSolid manages the infrastructure, MPC workflows, and strategy execution, while Partners retain control over user distribution and brand. Integration is flexible: RockSolid can deliver a fully managed vault integration (infrastructure, custody, strategy execution) or provide light-touch support to in-house development teams. ### Benefits for Protocols * **Increased TVL:** Depositors acquire or deposit the reference asset, creating structural buy-and-hold pressure and growing protocol liquidity. * **Negotiating leverage:** RockSolid, the Strategy Manager and the Partner Protocol can jointly negotiate improved incentives and integrations for the Partner Protocol's asset * **Revenue Sharing:** Vault economics generate both services fees (TVL-based) and rewards fees (a proportion of rewards earned by the vault), with a share directed to the Partner Protocol. * **Flexible Strategy Design:** Strategies can be tailored to protocol objectives: anywhere from conservative staking to more complex DeFi integrations (e.g. seeding liquidity). * **Low Engineering Lift:** RockSolid handles integration, audits, and operational controls, minimizing development overhead. ### Proof Points * RockSolid launched a flagship vault for the Rocket Pool protocol. This is the first and official vault dedicated to rETH. See the integration of RockSolid into the Rocket Pool [website](https://rocketpool.net/) and [staking app](https://stake.rocketpool.net/) for live examples. # Audits RockSolid uses the [ERC-7540 Asynchronous Tokenized Vault](https://eips.ethereum.org/EIPS/eip-7540) implementation by Lagoon Finance. You can find the most recent audits below: * [Version 0.5.0](https://2098527692-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F5vcVbvvRrtwZ0uaFrufF%2Fuploads%2FfnXfTtKlAKAD5g9oG2nS%2FNM_0581_FINAL_Lagoon.pdf?alt=media\&token=70a805bc-9317-4d29-b8bf-84d8ef242a94) * [Version 0.5.1](https://2098527692-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F5vcVbvvRrtwZ0uaFrufF%2Fuploads%2F8HkE2EU7hepf08gYGPsx%2FNM_0534_Lagoon.pdf?alt=media\&token=5884c02c-9290-4e7e-bebf-07f9aad8ba51) Historical audits are available [here](https://docs.lagoon.finance/resources/audits). RockSolid partnered with Hashlock to conduct a security penetration test of\ the project code base and an analysis and verification of the MPC wallet\ setup and policy controls, [see here for the detailed report](https://drive.google.com/file/d/1tWq3Dm8AHZ8FDy3P__3wuOvoJJifzRLr/view?usp=sharing).