Introduction

Stratum Protocol brings institutional-grade index investing to decentralized finance on Solana — enabling anyone to gain diversified crypto exposure through a single token.

The Problem

Cryptocurrency markets offer extraordinary opportunities, but navigating them remains overwhelmingly complex. Individual investors face a daunting landscape of thousands of tokens, each with unique risk profiles, liquidity characteristics, and technological underpinnings. Constructing a well-diversified portfolio requires constant monitoring, frequent rebalancing, deep market knowledge, and significant capital to spread across dozens of positions.

Traditional finance solved this problem decades ago with index funds — the S&P 500, NASDAQ-100, and FTSE 100 allow investors to buy the entire market in a single transaction. Yet crypto has lacked a trustless, on-chain equivalent that provides true diversification without custodial risk, bridge vulnerabilities, or opaque fund management.

Existing crypto index products suffer from critical limitations:

• Custodial risk — Most index products require trusting a centralized entity with your funds
• High fees — Traditional crypto funds charge 2-3% management fees annually
• Limited coverage — Most products only track 10-20 assets, missing the long tail of crypto value
• Cross-chain complexity — Physical replication requires bridging assets across chains, introducing systemic risk
• Slow rebalancing — Weekly or monthly rebalancing leads to tracking errors and stale compositions

The Solution

Stratum Protocol introduces synthetic, oracle-verified index tokens on Solana — a fundamentally new approach to crypto index investing. Instead of physically holding hundreds of underlying tokens, Stratum uses a USDC-collateralized vault combined with Pyth Network oracle price feeds to synthetically track the performance of up to 500 crypto assets in a single token.

This architecture eliminates bridge risk, removes DEX slippage from rebalancing, and enables daily reconstitution of index compositions — all while maintaining full transparency and trustless operation through Solana smart contracts.

Quick Links

What is Stratum?

Stratum is a decentralized index protocol on Solana that enables users to mint synthetic tokens representing diversified crypto market indices — bringing the simplicity of S&P 500 investing to DeFi.

Protocol Overview

Stratum Protocol is a suite of Solana smart contracts (programs) that together form a trustless index fund infrastructure. The protocol allows anyone to deposit USDC into a program-controlled vault and receive synthetic index tokens (S-tokens) that track the performance of a basket of cryptocurrencies, weighted by market capitalization.

Unlike traditional index funds that physically purchase and hold underlying assets, Stratum employs a synthetic replication model. The protocol holds USDC as collateral and uses Pyth Network oracle price feeds to calculate the Net Asset Value (NAV) of each index in real-time. This approach offers several fundamental advantages over physical replication, including elimination of cross-chain bridge risk, zero DEX slippage during rebalancing, and the ability to track hundreds of assets efficiently.

The Traditional Index Fund Analogy

To understand Stratum, consider how traditional index funds work in equities markets:

How Stratum Differs from Competitors

Several projects have attempted crypto index products, but each has significant limitations that Stratum addresses:

DeFi Pulse Index (DPI)

DPI by Index Coop is an Ethereum-based index tracking DeFi tokens. While pioneering, it physically holds only ~15 tokens, suffers from high Ethereum gas costs, requires complex multi-token management, and is limited to the DeFi sector. Stratum tracks up to 500 assets across all sectors with zero physical token management overhead.

Crypto20 (C20)

Crypto20 was an early crypto index fund tracking 20 assets. It operates as a centralized fund with custodial risk, limited transparency, and infrequent rebalancing. Stratum is fully decentralized with on-chain verifiable NAV and daily rebalancing.

Bitwise 10 / Grayscale

These institutional products offer crypto index exposure but require accredited investor status, charge 2-3% annual fees, and trade at premiums or discounts to NAV. Stratum is permissionless with 0.30% transaction fees and no annual management charge.

The Stratum Advantage

Why Stratum?

The crypto market is ready for institutional-grade index products. Stratum is purpose-built to fill this gap.

Market Opportunity

The total cryptocurrency market capitalization exceeds $2 trillion, yet index investing — which represents over $11 trillion in traditional equities — barely exists in crypto. This disparity represents one of the largest untapped opportunities in decentralized finance.

Consider the growth trajectory of index investing in traditional markets:

• 1976 — Vanguard launches the first index fund with $11 million in assets
• 1993 — SPY (the first S&P 500 ETF) launches
• 2024 — Index funds hold over $11 trillion in assets, representing 50%+ of US equity fund assets

Passive index investing has consistently outperformed active management over long time horizons. Academic research overwhelmingly supports the superiority of diversified, low-cost index exposure — and crypto markets are no exception.

Problems with Current Crypto Index Products

1. Custodial Risk

Most crypto index products require depositing funds with a centralized entity. The collapse of FTX, Celsius, and BlockFi demonstrated the catastrophic risk of custodial solutions. Users need index exposure without counterparty risk.

2. Limited Diversification

Existing on-chain index products typically track only 10-20 assets due to the operational complexity of physically holding and rebalancing multiple tokens across different chains. True market diversification requires much broader coverage.

3. High Fees

Centralized crypto index funds charge 1-3% annual management fees — orders of magnitude higher than equivalent equity index funds (0.03-0.20%). These fees compound significantly over time, eroding investor returns.

4. Cross-Chain Complexity

Physically replicating a broad crypto index requires holding tokens across Ethereum, Solana, Avalanche, Polygon, and dozens of other chains. Each bridge introduces smart contract risk, and managing liquidity across chains is operationally complex and expensive.

5. Rebalancing Inefficiency

Physical index products must actually execute trades to rebalance — selling tokens that have decreased in weight and buying those that have increased. On decentralized exchanges, this creates slippage, incurs gas costs, and results in front-running opportunities for MEV bots.

Stratum’s Value Propositions

Target Users

• Passive Investors — Buy-and-hold exposure to the entire crypto market without researching individual tokens
• DeFi Treasuries — DAOs seeking diversified crypto exposure for treasury management
• Portfolio Constructors — Builders using S-tokens as building blocks in structured DeFi strategies
• Institutional Allocators — Funds seeking on-chain, verifiable crypto market beta
• Developers — Build applications on top of Stratum’s index infrastructure using the SDK

Architecture

Stratum Protocol is composed of three specialized Solana programs that work together to provide trustless index token minting, redemption, and NAV tracking.

System Architecture Overview

The protocol follows a modular design philosophy where each program has a single, well-defined responsibility. This separation of concerns enhances security (each program has a minimal attack surface), upgradability (programs can be upgraded independently), and composability (external protocols can interact with specific components).

Program Descriptions

stratum-core

The core program serves as the central configuration and state registry for each index tier. It stores the current NAV, fee parameters, pause state, and authority information in the IndexConfig PDA. All other programs reference IndexConfig to read the current NAV and validate the protocol state.

Key responsibilities:

• Maintain authoritative NAV value for each index tier
• Store and enforce fee parameters (mint/redeem basis points)
• Provide emergency pause/unpause capability
• Manage authority transitions for protocol upgrades
• Enforce NAV deviation guards (maximum 20% change per update)

stratum-vault

The vault program manages all user-facing financial operations. It controls the USDC token account that holds collateral, the S-token mint authority, and fee accounting. The vault reads the current NAV from stratum-core to calculate mint/redeem amounts.

Key responsibilities:

• Accept USDC deposits and mint corresponding S-index tokens
• Accept S-index token burns and return proportional USDC
• Calculate mint/redeem quotes with fee deduction
• Accumulate protocol fees for later distribution
• Enforce slippage protection on all transactions
• Validate NAV staleness (reject operations if NAV older than 24 hours)

stratum-oracle

The oracle program manages the index composition and calculates NAV using Pyth Network price feeds. It stores constituent weights, validates price feed integrity, and computes the weighted-average index value that gets pushed to stratum-core.

Key responsibilities:

• Maintain list of index constituents with their weights and Pyth feed IDs
• Fetch and validate Pyth price feeds (staleness, confidence, deviation)
• Normalize prices from variable Pyth exponents to 8-decimal fixed-point
• Calculate weighted NAV from constituent prices
• Enforce confidence interval checks (price confidence must be <2% of price)
• Push updated NAV to stratum-core

Data Flow

The following sequence illustrates the complete data flow from a user depositing USDC to receiving S-index tokens:

1. Oracle Update (Keeper/Crank): An off-chain keeper triggers stratum-oracle::update_nav, which fetches current Pyth prices for all constituents, validates each price feed, computes the weighted NAV, and calls stratum-core::update_nav to store the result.
2. User Requests Quote: The user’s wallet or the dApp frontend calls stratum-vault::get_mint_quote with the desired USDC amount. The vault reads the current NAV from IndexConfig and calculates the expected S-token output after fees.
3. User Submits Mint Transaction: The user sends a transaction calling stratum-vault::mint with their USDC amount and minimum expected output (slippage protection). The vault transfers USDC from the user to the PDA-controlled vault account.
4. Vault Calculates Output: The vault computes: fee = usdc_amount × mint_fee_bps / 10000, net = usdc_amount - fee, tokens_out = net × NAV_PRECISION / current_nav. The fee is recorded in the fee accumulator.
5. S-Tokens Minted: The vault’s PDA mint authority mints the calculated S-tokens directly to the user’s associated token account. The transaction is complete in a single Solana block (~400ms).

PDA Authority Model

All value-holding accounts in Stratum are controlled by Program Derived Addresses (PDAs) — deterministic addresses that can only be signed by the program itself. No human holds a private key to the vault. This is the fundamental security guarantee of the protocol.

How It Works

A step-by-step walkthrough of the minting, redemption, and rebalancing processes that power Stratum Protocol.

Minting S-Index Tokens

Minting is the process of depositing USDC into the Stratum vault and receiving synthetic index tokens that track the performance of the chosen index tier. The process is atomic — it completes in a single Solana transaction.

1. Connect Wallet: The user connects their Solana wallet (Phantom, Solflare, Backpack, etc.) to the Stratum dApp at app.sxr.network.
2. Select Index Tier: Choose from S-500, S-250, S-100, or S-50 based on desired diversification level and risk profile.
3. Enter USDC Amount: Specify the amount of USDC to deposit. The dApp fetches a real-time quote showing the expected S-token output.
4. Review Quote: The quote displays: gross USDC amount, mint fee (0.30%), net USDC after fees, current NAV per token, and expected S-tokens to receive.
5. Approve & Sign: The user approves the transaction in their wallet. A single instruction transfers USDC and mints S-tokens atomically.
6. Receive Tokens: S-index tokens appear in the user’s wallet immediately. The tokens are standard SPL tokens, transferable and composable with other Solana DeFi protocols.

Worked Example

A user wants to mint S-500 tokens with 10,000 USDC. The current S-500 NAV is 1,247.83 (meaning 1 S-500 token represents $1,247.83 of index value):

Redeeming S-Index Tokens

Redemption is the reverse process: burning S-index tokens to withdraw the corresponding USDC value from the vault. Like minting, this is atomic and settles in a single transaction.

1. Select Redeem Tab: Navigate to the Redeem section in the dApp.
2. Enter Token Amount: Specify the number of S-tokens to burn. The dApp shows a real-time quote of the USDC to receive.
3. Review Quote: The quote shows: gross USDC value (tokens × NAV), redeem fee (0.30%), and net USDC to receive.
4. Approve & Sign: The user signs a single transaction that burns S-tokens and transfers USDC atomically.
5. Receive USDC: USDC appears in the user’s wallet immediately.

Worked Example

The same user later redeems 5 S-500 tokens when the NAV has risen to 1,312.45:

Daily Rebalancing Process

Stratum indices rebalance daily at 00:00 UTC to ensure the index composition reflects current market capitalizations. Unlike physical index funds, Stratum’s synthetic model means rebalancing requires no token swaps — only weight adjustments.

1. Fetch Rankings: The off-chain rebalancer fetches current market cap rankings from CoinGecko for all eligible tokens.
2. Apply Filters: Tokens are filtered through eligibility criteria: exclude stablecoins, wrapped tokens, and LST/LSD derivatives. Include memecoins if they qualify by market cap.
3. Calculate Weights: Market cap weights are computed for the top N tokens (500, 250, 100, or 50 depending on tier). Weights are expressed in basis points (1 bps = 0.01%).
4. Adjust Divisor: The index divisor is adjusted to ensure the index value remains continuous across the rebalance. This prevents any artificial jumps in index value due to composition changes.
5. Update On-Chain: The keeper submits transactions to stratum-oracle to update constituent weights, then triggers update_nav to compute the new NAV with updated composition.
6. Validate: The oracle program validates that all weights sum to 10,000 bps (100%) and that the new NAV doesn’t deviate more than 20% from the previous value.

NAV Calculation Walkthrough

The Net Asset Value (NAV) represents the fair price of one S-index token in USDC terms. It is computed on-chain by the oracle program using the following process:

1. For each constituent i in the index, fetch the Pyth price feed price_i
2. Validate the price: staleness < threshold, confidence < 2% of price
3. Normalize the price to 8-decimal fixed-point: normalized_i = price_i × 10^(8 + exponent_i)
4. Compute the weighted contribution: contribution_i = normalized_i × weight_bps_i
5. Sum all contributions: total = Σ(contribution_i)
6. Divide by total weight (10,000 bps): nav = total / 10,000
7. Scale to NAV precision (10⁶): final_nav = nav / 10^2 (from 8-decimal to 6-decimal)

Synthetic Index Design

Understanding why Stratum uses synthetic replication instead of physically holding underlying tokens, and the technical advantages this provides.

What is Synthetic Replication?

In traditional finance, index funds can track their benchmarks through two primary methods:

• Physical Replication: The fund actually purchases and holds all underlying assets in proportion to their index weights. An S&P 500 ETF like VOO physically holds shares of all 500 companies.
• Synthetic Replication: The fund holds collateral (typically cash or bonds) and uses derivative contracts (swaps) to replicate the index return. The fund doesn’t own the underlying assets directly.

Stratum uses a fully collateralized synthetic model: the protocol holds USDC as collateral and uses Pyth Network oracle price feeds to calculate the index value. No actual token swaps occur during normal operations or rebalancing.

Why Synthetic?

In the crypto context, synthetic replication provides decisive advantages over physical replication:

1. No Bridge Risk

A physically replicated crypto index tracking 500 tokens would need to hold assets across dozens of blockchains: Ethereum, Solana, Avalanche, Polygon, Cosmos, Arbitrum, and many more. Each cross-chain bridge introduces smart contract risk — and bridge hacks have resulted in billions of dollars in losses (Ronin: $625M, Wormhole: $320M, Nomad: $190M). Stratum eliminates this entire risk category by keeping all collateral as USDC on Solana.

2. No DEX Slippage

Physical rebalancing requires executing potentially hundreds of token swaps across multiple DEXs. Each swap incurs slippage, especially for less liquid tokens. For a large index fund rebalancing daily, this slippage compounds into significant tracking error. Stratum’s synthetic model rebalances by updating weight parameters — zero swaps, zero slippage.

3. Capital Efficiency

Physical replication requires holding hundreds of different token positions, each requiring separate token accounts, and dealing with the dust and rounding issues of managing many small positions. Stratum holds a single USDC pool, maximizing capital efficiency.

4. Unlimited Scalability

Adding a new constituent to a physical index requires sourcing liquidity, executing swaps, and managing new token accounts. Adding a constituent to a synthetic index requires only adding a Pyth price feed ID and a weight parameter. Stratum can scale to 500+ constituents with minimal overhead.

5. Instant Rebalancing

Physical rebalancing is a complex, multi-transaction process that can take hours and is vulnerable to front-running. Synthetic rebalancing updates weight parameters in a single transaction, taking effect instantly.

Physical vs. Synthetic: Detailed Comparison

USDC Collateral Model

All S-index tokens are fully backed by USDC held in PDA-controlled vault accounts. The collateralization ratio is always 1:1 with the aggregate NAV of all outstanding tokens. This means:

• If total outstanding S-500 tokens have a combined NAV of $10,000,000, the vault holds exactly $10,000,000 in USDC
• Any user can redeem their S-tokens for the fair USDC value at any time
• The vault balance is publicly verifiable on Solana Explorer
• No fractional reserve — the protocol is always fully collateralized

NAV Tracking Accuracy

The accuracy of Stratum’s NAV tracking depends on the quality of Pyth Network price feeds. Pyth provides institutional-grade price data with several quality guarantees:

• Sub-second update frequency — Pyth prices update every ~400ms on Solana
• Confidence intervals — Each price includes a confidence band, and Stratum rejects prices where confidence exceeds 2% of the price
• Multiple data sources — Pyth aggregates prices from dozens of institutional data providers
• Staleness protection — Stratum rejects prices older than a configurable threshold

Oracle System

How Stratum leverages Pyth Network’s institutional-grade oracle infrastructure to deliver accurate, tamper-resistant price data for NAV calculations.

Pyth Network Integration

Stratum Protocol uses Pyth Network as its primary oracle for price data. Pyth is the largest first-party oracle network, sourcing price data directly from institutional market participants including Jane Street, CBOE, Binance, OKX, and 90+ other data publishers.

Key characteristics of Pyth that make it ideal for Stratum:

• First-party data: Prices come directly from exchanges and trading firms, not scraped from public APIs
• Sub-second updates: On Solana, Pyth prices update every slot (~400ms)
• 500+ price feeds: Comprehensive coverage of crypto, equities, forex, and commodities
• Confidence intervals: Every price includes a statistical confidence band indicating data quality
• Pull oracle model: Consumers request the latest price on-demand, ensuring freshness

How Pyth Works on Solana

Pyth operates as a pull oracle on Solana. Unlike push oracles (like Chainlink on Ethereum) that periodically push prices on-chain regardless of demand, Pyth’s model works as follows:

1. Publishers Submit: 90+ institutional data publishers submit their observed prices to the Pyth network off-chain.
2. Aggregation: Pyth’s aggregation algorithm combines all publisher submissions into a single aggregate price with a confidence interval, using a robust median approach resistant to outliers.
3. On-Demand Posting: When a consumer (like Stratum) needs a price, it requests the latest Pyth price proof through the Pyth Solana receiver program, which verifies the price attestation on-chain.
4. Verification: The Pyth receiver program verifies the cryptographic signature of the price update, ensuring the data hasn’t been tampered with.
5. Consumption: Stratum’s oracle program reads the verified price from the Pyth account, validates it against quality criteria, and uses it in NAV calculations.

Price Feed Validation

Stratum applies rigorous validation to every Pyth price feed before using it in NAV calculations:

Confidence Interval Check

Pyth provides a confidence interval conf alongside each price price. The confidence represents the uncertainty in the aggregate price. Stratum requires:

This ensures that only high-quality, well-agreed-upon prices are used in NAV calculations. During periods of extreme volatility or thin liquidity where publishers disagree significantly, the confidence interval widens and the price may be rejected.

Supported Price Feeds

Pyth Network currently supports 500+ cryptocurrency price feeds, covering:

• Major cryptocurrencies: BTC, ETH, SOL, BNB, XRP, ADA, DOGE, and all top-100 tokens
• DeFi tokens: UNI, AAVE, MKR, COMP, SNX, CRV, and 100+ DeFi protocols
• Layer 2 / Alt-L1 tokens: ARB, OP, MATIC, AVAX, NEAR, APT, SUI
• Meme tokens: DOGE, SHIB, PEPE, WIF, BONK (when meeting market cap thresholds)
• Infrastructure tokens: LINK, GRT, FIL, AR, RENDER

The full list of supported feeds is available at pyth.network/price-feeds.

Backup Oracle Strategy

While Pyth Network provides highly reliable price data, Stratum implements multiple layers of resilience:

• Staleness Protection: If a Pyth feed goes stale, the constituent is temporarily excluded from NAV calculations using its last known weight contribution
• NAV Freezing: If more than 20% of constituent prices are stale, NAV updates are paused entirely, protecting users from inaccurate pricing
• Secondary Oracle (Planned): Integration with Switchboard as a secondary oracle for cross-validation of critical price feeds
• Emergency Pause: Protocol authority can pause all minting/redemption if oracle issues are detected

Index Tiers

Stratum offers four tiered index products, each providing different levels of diversification and risk exposure to the cryptocurrency market.

Overview

Stratum’s tiered index architecture is inspired by how traditional equity markets offer different index breadths — from the broad Russell 3000 to the concentrated Dow Jones 30. Each tier serves a different investor profile and risk appetite.

Tier Comparison

Choosing the Right Tier

Rule of thumb: If you’re unsure which tier to choose, start with S-250. It offers the best balance of diversification and quality filtering — equivalent to buying the crypto S&P 500.

• Choose S-500 if you want maximum diversification and believe small-cap crypto projects have asymmetric upside potential
• Choose S-250 if you want broad market exposure with a quality filter that removes the most speculative micro-caps
• Choose S-100 if you prefer established projects with proven track records and want more concentration than S-250
• Choose S-50 if you want a simple blue-chip allocation to crypto’s largest, most liquid assets

Methodology

The mathematical framework behind Stratum’s index calculation, inspired by the methodology used by the S&P 500 and other institutional indices.

Market Capitalization Weighting

Stratum indices use pure market capitalization weighting, the most widely used weighting methodology for equity and crypto indices. In a market-cap-weighted index, each constituent’s weight is proportional to its total market capitalization relative to the sum of all constituents’ market capitalizations.

This means:

• If Bitcoin has a market cap of $1.2T and the total market cap of all S-500 constituents is $2T, Bitcoin’s weight is 60%
• Weights naturally adjust as market caps change — outperforming tokens increase in weight, underperforming tokens decrease
• No arbitrary caps are applied — the index reflects the true market structure

Why Market-Cap Weighting?

Market capitalization weighting has several theoretical and practical advantages:

• Self-rebalancing: Price changes automatically adjust weights, reducing rebalancing frequency and cost
• Investability: Larger-cap tokens have deeper liquidity, so higher-weighted positions are the easiest to enter/exit
• Low turnover: Only composition changes (additions/removals) and weight drift require rebalancing
• Market efficiency: Cap weighting reflects the collective wisdom of all market participants about relative value

Free-Float Adjustment

In traditional equity indices, free-float adjustment excludes shares held by insiders, governments, and strategic investors. In the current version, Stratum uses total market capitalization without free-float adjustment, as reliable free-float data for crypto tokens is not consistently available.

Future versions may incorporate free-float adjustment using on-chain analytics to estimate the circulating supply more accurately, excluding locked tokens, team vesting schedules, and protocol-owned liquidity.

Index Base Value

All Stratum indices have a base value of 1,000 set at the inception date of January 1, 2025. This means that if the S-500 index shows a value of 1,247.83, the broad crypto market (as measured by the S-500 constituents) has appreciated 24.783% since inception.

Index Value Calculation

The index value is calculated using the divisor methodology, identical to the method used by S&P Dow Jones Indices for the S&P 500:

Where:

• Price_i — Current market price of constituent i (from Pyth oracle)
• Quantity_i — Number of units of constituent i in the index portfolio (derived from weight)
• Divisor — A normalization factor that ensures index continuity across rebalances
• N — Number of constituents in the index

On-Chain Implementation

On-chain, the calculation is simplified using basis-point weights instead of quantities:

Where WeightBpsi is the weight of constituent i expressed in basis points (0-10,000, where 10,000 = 100%). All weights must sum to exactly 10,000 bps, enforced by the validate_weights instruction.

Constituent Selection

Rules and criteria for determining which tokens are included in or excluded from Stratum indices.

Eligibility Criteria

To be eligible for inclusion in any Stratum index, a token must meet all of the following criteria:

1. Market Cap Ranking: Must be within the top N by market capitalization for the target tier (500, 250, 100, or 50)
2. Pyth Price Feed: Must have an active, reliable Pyth Network price feed available on Solana
3. Minimum Liquidity: Must have at least $1 million in daily trading volume averaged over the prior 30 days
4. Data Availability: Must be listed on CoinGecko with complete market cap data
5. Active Trading: Must have been actively traded for at least 30 consecutive days

Exclusion Rules

The following token categories are always excluded from Stratum indices, regardless of market cap ranking:

Inclusion Policy: Memecoins

Stratum indices do include memecoins (DOGE, SHIB, PEPE, WIF, BONK, etc.) if they meet all eligibility criteria and rank within the top N by market capitalization. This is a deliberate design choice:

• A true market-cap-weighted index should reflect the actual market structure, including speculative assets
• Excluding popular tokens by subjective “quality” criteria would introduce index provider bias
• Memecoins that achieve top-N market cap rankings represent genuine market demand and capital allocation
• Traditional indices (S&P 500) include speculative growth stocks like GameStop when they meet criteria — the same principle applies

Data Source

Constituent rankings and market capitalization data are sourced from CoinGecko via their API. CoinGecko was chosen because:

• Broadest token coverage (13,000+ tokens) with comprehensive market cap data
• Transparent methodology for calculating market cap and trading volume
• Free API tier sufficient for daily rebalancing operations
• Industry-standard data source used by most crypto index products

Rebalancing

How Stratum indices are reconstituted daily to reflect current market conditions, and the mechanisms that ensure index continuity.

Rebalancing Frequency

All Stratum indices rebalance daily at 00:00 UTC. This is significantly more frequent than traditional indices (S&P 500 rebalances quarterly) and most crypto index products (typically weekly or monthly). Daily rebalancing ensures:

• Index composition always reflects current market capitalizations
• Fast-moving crypto markets are captured accurately
• New entrants to the top N are included promptly
• Declining tokens are removed before they fall significantly further

Rebalancing Process

1. Fetch Current Rankings: At 00:00 UTC, the off-chain rebalancer queries CoinGecko for the current market cap rankings of all eligible tokens. The top 500 tokens (by market cap) that meet eligibility criteria are identified.
2. Apply Exclusion Filters: Stablecoins, wrapped tokens, and LST/LSD derivatives are removed from the ranking. Remaining tokens are re-ranked to fill the tier sizes.
3. Calculate New Weights: Market cap weights are computed for each constituent. Weights are expressed in basis points (bps) where 10,000 bps = 100%. Weight_i = floor(MarketCap_i / TotalMarketCap × 10,000).
4. Handle Rounding: Due to floor rounding, weights may sum to slightly less than 10,000. The remainder is distributed proportionally among the largest constituents to ensure the total is exactly 10,000 bps.
5. Calculate Divisor Adjustment: Before updating weights, the divisor is adjusted so that the index value remains continuous across the rebalance (see Divisor Method section).
6. Submit On-Chain Updates: The keeper submits transactions to stratum-oracle: first add_constituent/remove_constituent for composition changes, then weight updates for existing constituents, and finally validate_weights to verify the sum equals 10,000.
7. Trigger NAV Update: After weights are validated, the keeper triggers update_nav to compute the new NAV with the updated composition. The oracle validates that the new NAV is within 20% of the previous value.

Constituent Changes

Additions

When a token enters the top N ranking and meets all eligibility criteria, it is added to the index at the next daily rebalance. The add_constituent instruction creates a new ConstituentWeight PDA with the token’s CoinGecko ID, Pyth feed ID, and initial weight.

Removals

When a token falls below rank N+buffer (see Buffer Zone below) or fails to meet eligibility criteria, it is removed at the next daily rebalance. The remove_constituent instruction closes the ConstituentWeight PDA and returns rent to the authority.

Buffer Zone

To prevent excessive turnover from tokens oscillating around the boundary, Stratum implements a buffer zone. A token currently in the index is only removed if it falls below rank N+25. A token not currently in the index is only added if it rises to rank N or above.

For example, in the S-100 index:

• A new token must reach rank 100 or higher to be added
• An existing token is only removed if it falls to rank 126 or below
• Tokens ranked 101-125 that are already in the index remain; those not in the index stay out

This buffer reduces unnecessary churn and the associated gas costs of on-chain updates.

Divisor Method

The mathematical mechanism that ensures index value continuity across rebalancing events — the same methodology used by S&P Dow Jones Indices.

What is the Divisor?

The divisor is a normalization factor that translates the raw sum of constituent market values into the index value. Its primary purpose is to ensure that non-market events (like rebalancing, constituent changes, or corporate actions in traditional markets) do not cause artificial jumps in the index value.

Without a divisor adjustment, adding a new large-cap constituent to the index would immediately increase the index value — even though no actual market movement occurred. The divisor corrects for this.

How It Works

The fundamental principle is: the index value must be the same immediately before and after any non-market change.

Where:

• New Sum of Market Values = the sum of (Price_i × Quantity_i) for the new composition
• Current Index Value = the index value immediately before the rebalance

Worked Example

Consider a simplified S-3 index with 3 constituents:

Before Rebalance

Current Divisor = 36,542 / 1,247.50 = 29.29
Current Index Value = 36,542 / 29.29 = 1,247.50

After Rebalance (SOL replaced by BNB)

New Divisor = 36,546.75 / 1,247.50 = 29.293

Result: The index value immediately after the rebalance is still 36,546.75 / 29.293 = 1,247.50. The constituent change did not affect the index value. Only subsequent market price movements will change it.

Why This Matters

• Continuity: Investors can track long-term performance without rebalancing artifacts
• Accuracy: The index accurately measures pure market performance, not operational noise
• Trustworthiness: Users can verify that index changes are fair and don’t create artificial gains or losses
• Industry Standard: This is the exact same methodology used by S&P 500, DJIA, NASDAQ-100, and all major equity indices

$STRAT Token

The governance and utility token powering the Stratum Protocol ecosystem.

Token Overview

$STRAT is the native governance and utility token of Stratum Protocol. It serves as the coordination mechanism for protocol governance, fee sharing, and incentive alignment between protocol participants.

Distribution

$STRAT follows a fair launch model via pump.fun, ensuring broad community distribution from day one. The initial distribution is designed to maximize decentralization while retaining sufficient allocation for protocol development and ecosystem growth.

Fair Launch Philosophy

Stratum Protocol deliberately chose a fair launch model over traditional VC-funded token launches for several reasons:

• No insider advantage: No pre-sale rounds mean no early investors can dump on retail participants
• Community-first: The broadest possible distribution from day one creates a more robust governance base
• Alignment: Team tokens vest over 3 years, ensuring long-term alignment with the protocol’s success
• Transparency: pump.fun’s bonding curve mechanism provides transparent, predictable price discovery

Token Utility

$STRAT is designed with multiple utility functions that create sustainable demand and align stakeholder incentives.

Utility Overview

$STRAT serves eight distinct functions within the Stratum Protocol ecosystem, each creating organic demand for the token:

Fee Discount Tiers

Fee discount eligibility is checked on-chain at the time of each mint/redeem transaction by reading the user’s $STRAT token balance. No staking is required for fee discounts — simply holding the tokens in your wallet qualifies you.

Fee Structure

Stratum’s transparent, minimal fee structure designed to maximize value for users while sustaining protocol development.

Transaction Fees

Fee Distribution

All collected fees (mint + redeem) are distributed as follows:

Comparison with Traditional Products

Stratum’s fee structure is dramatically more competitive than both traditional crypto funds and emerging DeFi index products:

For a $10,000 investment held for one year, the total cost comparison is:

• Stratum: $60 (0.60% one-time)
• Grayscale: $300 (2.50% annually + spread)
• DPI: $155 (0.95% annually + swap fee)

Staking & Rewards

Earn USDC rewards by staking $STRAT tokens and participating in protocol security.

How Staking Works

$STRAT staking is a simple, non-custodial mechanism that allows token holders to earn a share of protocol revenue. Staked tokens remain on-chain in a PDA-controlled staking contract — you retain full ownership at all times.

1. Deposit $STRAT: Send your $STRAT tokens to the staking contract via the Stratum dApp. Your tokens are locked in a PDA-controlled account.
2. Accrue Rewards: As users mint and redeem S-index tokens, 50% of all protocol fees are directed to the staking reward pool in USDC.
3. Claim Rewards: USDC rewards are claimable at any time. Rewards accrue continuously and are calculated proportionally to your share of the total staked supply.
4. Unstake: Request unstaking to begin the cooldown period. After the cooldown expires, withdraw your $STRAT tokens back to your wallet.

APY Calculation

The staking APY is dynamic and depends on two variables: total protocol fee revenue and total $STRAT staked.

Example Scenario

Reward Distribution

• Currency: Rewards are paid in USDC, not $STRAT. This avoids sell pressure from reward emissions.
• Frequency: Rewards accrue per-block and are claimable at any time.
• Calculation: Your reward share = (your staked $STRAT / total staked $STRAT) × reward pool.
• Compounding: USDC rewards do not auto-compound. You can manually reinvest by buying more $STRAT.

Unstaking Cooldown

To prevent flash-loan attacks and ensure staking stability, a 7-day cooldown period applies when unstaking:

• Day 0: Request unstake — tokens are marked for withdrawal, stop earning rewards
• Days 1-7: Cooldown period — tokens are locked, no rewards accrue
• Day 7+: Tokens are withdrawable — claim your $STRAT back to your wallet

Buyback & Burn

A deflationary mechanism that permanently removes $STRAT from circulation using protocol revenue.

Mechanism Overview

10% of all protocol fees are allocated to the buyback & burn mechanism. This creates continuous, organic buy pressure for $STRAT while permanently reducing the circulating supply.

1. Fee Accumulation: As users mint and redeem S-tokens, 10% of each fee is directed to the buyback accumulator account (USDC).
2. Automated Buyback: When the accumulator reaches a threshold (initially $1,000 USDC), a keeper triggers the buyback instruction. The USDC is swapped for $STRAT via Jupiter aggregator, using optimal routing across all Solana DEXs.
3. Permanent Burn: The purchased $STRAT tokens are sent to a verified burn address (a PDA with no possible signer). The tokens are permanently removed from circulation.
4. On-Chain Verification: Every buyback and burn transaction is recorded on-chain with full transparency. A running total of burned tokens is maintained in the protocol state.

Deflationary Impact

The buyback & burn mechanism creates a deflationary supply dynamic:

*Assuming $STRAT price of $3.47. Actual burn amounts vary with market price.

Design Rationale

• Sustainable demand: Buybacks create consistent bid-side pressure proportional to protocol usage
• Supply reduction: Burns permanently reduce the maximum supply, increasing scarcity over time
• Alignment: Protocol success (more volume = more fees) directly translates to $STRAT value accrual
• Transparency: All buyback transactions are executed on-chain via Jupiter and fully auditable

Governance

Stratum Protocol is governed by $STRAT token holders through an on-chain governance framework that controls all configurable protocol parameters.

Governance Scope

$STRAT governance has authority over the following protocol parameters and decisions:

Governance Roadmap

Stratum follows a progressive decentralization approach:

Phase 1: Foundation (Current)

The core team maintains upgrade authority over all programs. Governance proposals are discussed in community forums and Discord, with the team implementing approved changes. This allows rapid iteration and bug fixes during the early protocol phase.

Phase 2: Shared Governance (Q3 2025)

Introduction of on-chain voting via $STRAT tokens. A multisig (3-of-5) replaces the single team authority. Governance proposals require on-chain votes, but the multisig retains emergency override capability.

Phase 3: Full Decentralization (Q1 2026)

Program upgrade authority is transferred to the governance contract. All parameter changes require on-chain governance votes. Emergency pause remains available but is governed by a security council elected by $STRAT holders.

Proposal Process

The structured process for submitting, discussing, and implementing governance proposals.

Proposal Lifecycle

1. Forum Discussion (3–7 days): Any community member can create a proposal thread in the Stratum governance forum. The proposal must include a clear title, motivation, specification of changes, and expected impact. Community members discuss, provide feedback, and suggest modifications. A minimum of 3 days of discussion is required before advancing.
2. Formal Proposal Submission: After sufficient discussion and incorporating community feedback, the proposer creates a formal on-chain proposal. This requires holding at least 10,000 $STRAT tokens (the proposal threshold). The proposal includes the exact parameter changes or code upgrades to be executed.
3. Voting Period (3 days): Once submitted on-chain, a 3-day voting window opens. All $STRAT holders can vote FOR, AGAINST, or ABSTAIN. Votes are weighted by token balance at the snapshot block (taken at proposal submission). Delegated votes are supported.
4. Implementation (if passed): If the proposal passes quorum and approval thresholds, it enters a 24-hour timelock before execution. This gives users time to react to approved changes (e.g., by exiting positions). After the timelock, the changes are executed on-chain.

Proposal Template

# SIP-[NUMBER]: [Title]

## Summary
One-paragraph description of the proposed change.

## Motivation
Why is this change needed? What problem does it solve?

## Specification
Exact parameters to change, new values, and technical details.

## Rationale
Why this approach over alternatives?

## Risk Assessment
Potential risks and mitigation strategies.

## Voting
- FOR: Implement the changes as specified
- AGAINST: Reject the proposal
- ABSTAIN: No preference

Proposal Types

Voting Mechanism

Technical details of the on-chain voting system powered by $STRAT tokens.

Vote Weighting

Stratum uses a simple, transparent vote weighting model:

Voting power is determined by the $STRAT balance at the snapshot block, which is taken at the moment a proposal is submitted on-chain. This prevents flash-loan vote manipulation.

Quorum Requirements

For a vote to be valid, the total votes cast (FOR + AGAINST + ABSTAIN) must exceed the quorum threshold. ABSTAIN votes count toward quorum but not toward the approval ratio.

Delegation

$STRAT holders can delegate their voting power to another address without transferring tokens. This enables:

• Passive holders to participate in governance through trusted delegates
• Community leaders to accumulate voting power for proposals they champion
• Delegation is revocable at any time and takes effect in the next proposal

Supermajority Governance

Critical protocol changes require a supermajority of 66.67% FOR votes. This higher bar ensures broad consensus for changes that could fundamentally alter the protocol:

• Program upgrades or migrations
• Authority transitions
• Changes to governance parameters themselves
• Emergency powers modification
• New index tier creation

Quick Start

Get up and running with Stratum Protocol in under 5 minutes. This guide shows you how to install the SDK, connect to the protocol, and execute your first mint.

Prerequisites

• Node.js 18+ and npm
• A Solana wallet with SOL for transaction fees
• USDC tokens (SPL) for minting index tokens
• Basic familiarity with Solana and TypeScript

Installation

npm install @stratum/sdk @solana/web3.js @coral-xyz/anchor

Initialize Client

import { Connection, Keypair } from '@solana/web3.js';
import { AnchorProvider, Wallet } from '@coral-xyz/anchor';
import { StratumClient, IndexTier } from '@stratum/sdk';

// Connect to Solana
const connection = new Connection('https://api.mainnet-beta.solana.com');
const wallet = new Wallet(Keypair.generate()); // Use your wallet
const provider = new AnchorProvider(connection, wallet, {});

// Initialize Stratum client
const client = new StratumClient(provider);

Get a Mint Quote

// Get a quote for minting S-500 tokens with 1,000 USDC
const quote = await client.getMintQuote(
  IndexTier.S500,
  1000 * 1e6  // 1,000 USDC (6 decimals)
);

console.log('Mint Quote:');
console.log(' USDC In:    ', quote.usdcAmount / 1e6);
console.log(' Fee:        ', quote.fee / 1e6, 'USDC');
console.log(' Tokens Out: ', quote.tokensOut / 1e6);
console.log(' NAV:        ', quote.nav / 1e6);

Execute a Mint

// Mint S-500 tokens with 1,000 USDC
// minTokensOut provides slippage protection
const signature = await client.mint({
  tier: IndexTier.S500,
  usdcAmount: 1000 * 1e6,
  minTokensOut: quote.tokensOut * 0.995,  // 0.5% slippage tolerance
});

console.log('Mint successful!');
console.log('Transaction:', signature);

Execute a Redeem

// Redeem 5 S-500 tokens back to USDC
const redeemQuote = await client.getRedeemQuote(
  IndexTier.S500,
  5 * 1e6  // 5 tokens (6 decimals)
);

const redeemSig = await client.redeem({
  tier: IndexTier.S500,
  tokenAmount: 5 * 1e6,
  minUsdcOut: redeemQuote.usdcOut * 0.995,  // 0.5% slippage
});

console.log('Redeemed:', redeemQuote.usdcOut / 1e6, 'USDC');

Read Index Data

// Fetch current index statistics
const stats = await client.getIndexStats(IndexTier.S500);

console.log('S-500 Index Stats:');
console.log(' NAV:           ', stats.nav / 1e6);
console.log(' Total Supply:  ', stats.totalSupply / 1e6);
console.log(' TVL (USDC):    ', stats.tvl / 1e6);
console.log(' Mint Fee:      ', stats.mintFeeBps, 'bps');
console.log(' Last Updated:  ', new Date(stats.lastUpdate * 1000));

// Fetch vault statistics
const vault = await client.getVaultStats(IndexTier.S500);
console.log(' Vault USDC:    ', vault.totalUsdc / 1e6);
console.log(' Fees Accrued:  ', vault.feesAccrued / 1e6);

SDK Reference

Complete API reference for the @stratum/sdk TypeScript package.

Installation

npm install @stratum/sdk
# Peer dependencies (install if not already present)
npm install @solana/web3.js @coral-xyz/anchor @solana/spl-token

StratumClient Class

The main entry point for all protocol interactions.

class StratumClient {
  constructor(provider: AnchorProvider);

  // ── Read Methods ──
  getIndexConfig(tier: IndexTier): Promise<IndexConfig>;
  getVaultState(tier: IndexTier): Promise<VaultState>;
  getOracleConfig(tier: IndexTier): Promise<OracleConfig>;
  getConstituentWeight(tier: IndexTier, index: number): Promise<ConstituentWeight>;
  getAllConstituents(tier: IndexTier): Promise<ConstituentWeight[]>;
  getIndexStats(tier: IndexTier): Promise<IndexStats>;
  getVaultStats(tier: IndexTier): Promise<VaultStats>;

  // ── Quote Methods ──
  getMintQuote(tier: IndexTier, usdcAmount: number): Promise<MintQuote>;
  getRedeemQuote(tier: IndexTier, tokenAmount: number): Promise<RedeemQuote>;

  // ── Write Methods ──
  mint(params: MintParams): Promise<string>;
  redeem(params: RedeemParams): Promise<string>;

  // ── PDA Helpers ──
  getIndexConfigPDA(authority: PublicKey, tier: IndexTier): PublicKey;
  getVaultStatePDA(indexConfig: PublicKey): PublicKey;
  getVaultAuthorityPDA(indexConfig: PublicKey): PublicKey;
  getIndexMintPDA(indexConfig: PublicKey): PublicKey;
  getOracleConfigPDA(indexConfig: PublicKey): PublicKey;
  getConstituentPDA(oracleConfig: PublicKey, index: number): PublicKey;
}

Type Definitions

enum IndexTier {
  S500 = 0,
  S250 = 1,
  S100 = 2,
  S50  = 3,
}

interface IndexConfig {
  authority: PublicKey;
  tier: IndexTier;
  currentNav: BN;         // 6-decimal fixed-point
  mintFeeBps: number;     // basis points (30 = 0.30%)
  redeemFeeBps: number;
  isPaused: boolean;
  lastUpdateTs: BN;      // Unix timestamp
  totalMinted: BN;       // cumulative tokens minted
  bump: number;
}

interface VaultState {
  indexConfig: PublicKey;
  usdcMint: PublicKey;
  usdcVault: PublicKey;    // PDA-controlled USDC account
  indexMint: PublicKey;    // S-token mint
  totalUsdc: BN;          // USDC in vault
  totalSupply: BN;        // outstanding S-tokens
  feesAccrued: BN;        // unclaimed fees in USDC
  bump: number;
}

interface MintQuote {
  usdcAmount: number;     // USDC input (6 decimals)
  fee: number;            // fee in USDC
  netUsdc: number;        // USDC after fee
  tokensOut: number;      // S-tokens to receive
  nav: number;            // current NAV used
  feeBps: number;         // fee rate in bps
}

interface RedeemQuote {
  tokenAmount: number;    // S-tokens to burn
  grossUsdc: number;      // USDC before fee
  fee: number;            // fee in USDC
  usdcOut: number;        // net USDC to receive
  nav: number;            // current NAV used
  feeBps: number;
}

Program Architecture

Technical reference for the three Solana programs that compose Stratum Protocol.

Program Overview

stratum-core Instructions

stratum-vault Instructions

stratum-oracle Instructions

Account Structures

#[account]
pub struct IndexConfig {
    pub authority: Pubkey,
    pub tier: IndexTier,
    pub current_nav: u64,         // NAV with 6 decimal precision
    pub mint_fee_bps: u16,       // basis points (30 = 0.30%)
    pub redeem_fee_bps: u16,
    pub is_paused: bool,
    pub last_update_ts: i64,     // Unix timestamp of last NAV update
    pub total_minted: u64,       // cumulative tokens minted (lifetime)
    pub bump: u8,
}

#[account]
pub struct VaultState {
    pub index_config: Pubkey,
    pub usdc_mint: Pubkey,
    pub usdc_vault: Pubkey,       // PDA-controlled USDC token account
    pub index_mint: Pubkey,      // SPL mint for S-tokens
    pub total_usdc: u64,         // USDC deposited in vault
    pub total_supply: u64,       // outstanding S-tokens
    pub fees_accrued: u64,       // unclaimed fees (USDC)
    pub bump: u8,
}

#[account]
pub struct OracleConfig {
    pub index_config: Pubkey,
    pub authority: Pubkey,
    pub constituent_count: u16,  // number of active constituents
    pub total_weight: u16,       // sum of all weights (must be 10000)
    pub last_nav_update: i64,    // timestamp of last NAV calculation
    pub bump: u8,
}

#[account]
pub struct ConstituentWeight {
    pub oracle_config: Pubkey,
    pub coin_gecko_id: String,   // e.g., "bitcoin", "ethereum"
    pub pyth_feed_id: Pubkey,    // Pyth price feed account
    pub weight_bps: u16,         // weight in basis points
    pub coin_index: u16,         // position in constituent array
    pub last_price: u64,         // last recorded price (8 decimals)
    pub bump: u8,
}

PDA Reference

Complete reference for all Program Derived Addresses (PDAs) used across the three Stratum programs, including seeds, derivation code, and account ownership.

PDA Summary Table

Rust Derivation Examples

use anchor_lang::prelude::*;

// IndexConfig PDA
let tier_byte = [tier as u8];
let (index_config_pda, bump) = Pubkey::find_program_address(
    &[
        b"index_config",
        authority.as_ref(),
        &tier_byte,
    ],
    &stratum_core::id(),
);

// VaultState PDA
let (vault_state_pda, _) = Pubkey::find_program_address(
    &[
        b"vault_state",
        index_config_pda.as_ref(),
    ],
    &stratum_vault::id(),
);

// VaultAuthority PDA (signer for transfers)
let (vault_authority_pda, _) = Pubkey::find_program_address(
    &[
        b"vault_authority",
        index_config_pda.as_ref(),
    ],
    &stratum_vault::id(),
);

// IndexMint PDA (S-token mint)
let (index_mint_pda, _) = Pubkey::find_program_address(
    &[
        b"index_mint",
        index_config_pda.as_ref(),
    ],
    &stratum_vault::id(),
);

// OracleConfig PDA
let (oracle_config_pda, _) = Pubkey::find_program_address(
    &[
        b"oracle_config",
        index_config_pda.as_ref(),
    ],
    &stratum_oracle::id(),
);

// ConstituentWeight PDA (for constituent at index 42)
let coin_index: u16 = 42;
let (constituent_pda, _) = Pubkey::find_program_address(
    &[
        b"constituent",
        oracle_config_pda.as_ref(),
        &coin_index.to_le_bytes(),
    ],
    &stratum_oracle::id(),
);

TypeScript Derivation Examples

import { PublicKey } from '@solana/web3.js';

const CORE_PROGRAM_ID = new PublicKey('Fg6Pa...LnS');
const VAULT_PROGRAM_ID = new PublicKey('HmbTL...KPQ');
const ORACLE_PROGRAM_ID = new PublicKey('3TmME...Kxa');

// IndexConfig PDA
function getIndexConfigPDA(
  authority: PublicKey,
  tier: number // 0=S500, 1=S250, 2=S100, 3=S50
): PublicKey {
  const [pda] = PublicKey.findProgramAddressSync(
    [
      Buffer.from('index_config'),
      authority.toBuffer(),
      Buffer.from([tier]),
    ],
    CORE_PROGRAM_ID
  );
  return pda;
}

// VaultState PDA
function getVaultStatePDA(indexConfig: PublicKey): PublicKey {
  const [pda] = PublicKey.findProgramAddressSync(
    [Buffer.from('vault_state'), indexConfig.toBuffer()],
    VAULT_PROGRAM_ID
  );
  return pda;
}

// ConstituentWeight PDA
function getConstituentPDA(
  oracleConfig: PublicKey,
  coinIndex: number
): PublicKey {
  const buf = Buffer.alloc(2);
  buf.writeUInt16LE(coinIndex);
  const [pda] = PublicKey.findProgramAddressSync(
    [Buffer.from('constituent'), oracleConfig.toBuffer(), buf],
    ORACLE_PROGRAM_ID
  );
  return pda;
}

API Reference

REST API and WebSocket endpoints provided by the Stratum backend service for off-chain data access and real-time streaming.

Base URL

https://api.sxr.network/v1

Authentication

All read endpoints are public and require no authentication. Write endpoints (admin operations) require an API key passed via the X-API-Key header.

REST Endpoints

GET /indices

Returns a list of all available index tiers with current statistics.

{
  "indices": [
    {
      "tier": "S500",
      "name": "Stratum 500",
      "nav": 1247.830000,
      "nav_change_24h": 2.45,
      "tvl": 45230000.00,
      "total_supply": 36250.543210,
      "constituent_count": 500,
      "last_rebalance": "2025-03-01T00:00:00Z",
      "mint_fee_bps": 30,
      "redeem_fee_bps": 30
    }
  ]
}

GET /indices/{tier}

Returns detailed information for a specific index tier. Tier values: S500, S250, S100, S50.

GET /indices/{tier}/constituents

Returns all constituents of the specified index with their current weights, prices, and market cap data.

{
  "tier": "S500",
  "constituent_count": 500,
  "constituents": [
    {
      "rank": 1,
      "symbol": "BTC",
      "name": "Bitcoin",
      "coingecko_id": "bitcoin",
      "price": 62450.23,
      "market_cap": 1224000000000,
      "weight_bps": 6234,
      "weight_pct": 62.34,
      "price_change_24h": 1.82
    }
  ]
}

GET /indices/{tier}/nav/history

Returns historical NAV data for charting. Query parameters:

• period — 1d, 7d, 30d, 90d, 1y, all (default: 30d)
• interval — 1h, 4h, 1d (default: auto-selected based on period)

GET /quote/mint

Get a mint quote. Query parameters: tier, usdc_amount (in raw units, 6 decimals).

GET /quote/redeem

Get a redeem quote. Query parameters: tier, token_amount (in raw units, 6 decimals).

GET /protocol/stats

Returns aggregate protocol statistics: total TVL, total fees collected, total tokens minted/burned, and 24h volume.

WebSocket Streaming

wss://api.sxr.network/ws/v1/stream

Subscription Message

{
  "action": "subscribe",
  "channels": ["nav", "trades", "rebalance"],
  "tiers": ["S500", "S100"]
}

Event Types

Security Model

A comprehensive overview of the security architecture protecting user funds and protocol integrity in Stratum Protocol.

Core Security Principles

1. PDA-Controlled Vault

All user USDC deposits are held in a token account owned by a Program Derived Address (PDA). This is the cornerstone of Stratum’s security model:

• No private key exists for the vault authority PDA — it falls off the Ed25519 elliptic curve
• Only the stratum-vault program can generate valid signatures for the vault authority PDA
• Fund movements are governed entirely by program logic, not by any human or multisig
• Verifiable on-chain — anyone can inspect the vault PDA owner and confirm it matches the stratum-vault program ID

2. Checked Arithmetic

All mathematical operations in Stratum use Rust’s checked_* arithmetic methods, which return errors on overflow or underflow instead of silently wrapping. This prevents an entire category of exploits common in early smart contracts:

// Safe arithmetic — panics on overflow instead of wrapping
let fee = usdc_amount
    .checked_mul(mint_fee_bps as u64)
    .ok_or(StratumError::MathOverflow)?
    .checked_div(BPS_DENOMINATOR)
    .ok_or(StratumError::MathOverflow)?;

let net_amount = usdc_amount
    .checked_sub(fee)
    .ok_or(StratumError::MathOverflow)?;

3. Reentrancy Protection

Solana’s runtime provides inherent reentrancy protection: a program cannot call itself recursively within a single transaction. Additionally, Stratum follows the checks-effects-interactions pattern, updating state before making any external calls (token transfers).

4. Emergency Pause

The protocol authority can pause all minting and redemption operations instantly. When paused:

• All mint and redeem instructions return ProtocolPaused error
• NAV updates continue (so the protocol can resume with accurate pricing)
• Existing token holders retain their tokens and can transfer freely
• Only the authority can unpause

5. Admin Key Security

During the initial launch phase, the protocol authority is a team-controlled wallet. The security roadmap includes:

• Phase 1 (Launch): Single admin key stored in hardware wallet
• Phase 2 (3 months): Migration to 3-of-5 Squads multisig
• Phase 3 (12 months): Authority transfer to on-chain governance contract

Input Validation

Every instruction performs comprehensive input validation:

Oracle Security

Defense-in-depth measures protecting NAV calculations from oracle manipulation, stale data, and adversarial conditions.

Pyth Confidence Intervals

Every Pyth price feed includes a confidence interval representing the statistical uncertainty of the aggregate price. Stratum enforces:

If any constituent’s price confidence exceeds 2%, that constituent is excluded from the NAV calculation for that update. This protects against:

• Flash crashes where publishers disagree on price
• Low-liquidity periods where price discovery is unreliable
• Oracle manipulation attempts where a single publisher submits extreme values

Staleness Validation

Each Pyth price update includes a timestamp. Stratum validates that the price timestamp is within a configurable staleness threshold (default: 60 seconds for individual prices, 24 hours for aggregate NAV staleness).

• Individual price staleness: If a constituent’s price is stale, it is excluded from the current NAV update
• NAV staleness (24h): If the overall NAV hasn’t been updated in 24 hours, all mint/redeem operations are blocked until a fresh NAV update is submitted

Deviation Bounds

The update_nav instruction enforces a maximum deviation of 20% between the new NAV and the previous NAV. This circuit breaker prevents catastrophic NAV manipulation:

let deviation = if new_nav > old_nav {
    (new_nav - old_nav) * BPS_DENOMINATOR / old_nav
} else {
    (old_nav - new_nav) * BPS_DENOMINATOR / old_nav
};
require!(
    deviation <= MAX_NAV_DEVIATION_BPS, // 2000 = 20%
    StratumError::NavDeviationExceeded
);

Multiple Oracle Sources (Roadmap)

Future protocol versions will implement a multi-oracle consensus mechanism:

• Primary: Pyth Network (current)
• Secondary: Switchboard Oracle (planned Q3 2025)
• Tertiary: On-chain TWAP from major Solana DEXs (planned Q4 2025)
• Consensus rule: Median of available sources, with outlier rejection

Risk Parameters

Configurable parameters that bound protocol behavior and protect users from extreme market conditions.

Parameter Reference

Slippage Protection

Every mint and redeem transaction includes a user-specified min_tokens_out (for mints) or min_usdc_out (for redeems) parameter. If the actual output is less than this minimum, the entire transaction reverts. This protects users from:

• NAV changes between quote time and execution time
• Front-running by MEV bots monitoring the mempool
• Oracle price movements during transaction confirmation

Risk Considerations

Audit Status

Current audit status, planned timeline, and bug bounty program for Stratum Protocol.

Current Status

Planned Audit Timeline

Audit Firm Selection Criteria

• Solana expertise: Must have completed 5+ Solana program audits
• Anchor familiarity: Deep experience with the Anchor framework
• DeFi specialization: Prior work auditing vault, oracle, and token protocols
• Reputation: Recognized standing in the security research community
• Thoroughness: Manual review combined with automated tooling (Soteria, Sec3, custom fuzzers)

Bug Bounty Program (Planned)

After the formal audit, Stratum will launch a bug bounty program with the following structure:

Frequently Asked Questions

Answers to the most common questions about Stratum Protocol, index investing, and the $STRAT token.

General

What is an index fund?

An index fund is an investment vehicle that tracks the performance of a specific market index — a predefined basket of assets weighted by some criteria (usually market capitalization). Instead of picking individual stocks or tokens, you buy one fund that gives you exposure to the entire market or a segment of it. The most famous example is the S&P 500 index fund, which tracks the 500 largest US companies. Stratum brings this concept to crypto: instead of picking individual tokens, you buy one S-token that tracks the top 50, 100, 250, or 500 cryptocurrencies.

How is this different from buying BTC?

Buying BTC gives you exposure to a single asset. If BTC outperforms the market, great — but if the next big innovation happens in DeFi, AI tokens, or a new blockchain ecosystem, you miss out. Stratum index tokens give you diversified exposure to the entire crypto market. If any token in the index performs well, your S-token captures that value proportionally. Historically, diversified portfolios have lower volatility and more consistent long-term returns than concentrated single-asset positions.

Are my funds safe?

Your USDC deposits are held in a PDA-controlled vault on Solana. No human has a private key to access these funds — only the stratum-vault program can move USDC, and it will only do so in response to valid mint/redeem transactions. The vault balance is publicly verifiable on Solana Explorer at any time. That said, all smart contracts carry inherent risk, and the protocol has not yet been formally audited. Please only invest what you can afford to lose.

What fees do I pay?

Stratum charges a 0.30% fee on minting (depositing USDC) and a 0.30% fee on redemption (withdrawing USDC). There are no annual management fees, no performance fees, and no hidden charges. Holding $STRAT tokens can reduce your fees to as low as 0.10%. For a round-trip (mint + redeem), your total fee is 0.60% — significantly lower than traditional crypto funds charging 2-3% annually.

How often does it rebalance?

All Stratum indices rebalance daily at 00:00 UTC. During rebalancing, constituent weights are recalculated based on current market capitalizations from CoinGecko data. Because Stratum uses synthetic replication, rebalancing requires no token swaps — only weight parameter updates. This makes daily rebalancing practical and cost-effective, ensuring your index always reflects the current market structure.

Risk & Safety

Can I lose money?

Yes. S-index tokens track the crypto market. If the overall crypto market declines, the NAV of your S-tokens will decline proportionally. Stratum provides diversified exposure, which reduces the risk of any single token crashing to zero, but it does not protect against broad market downturns. Crypto markets are highly volatile — only invest what you can afford to lose.

How is NAV calculated?

NAV (Net Asset Value) is the fair price of one S-index token in USDC. It is calculated on-chain by the stratum-oracle program using Pyth Network price feeds. For each constituent in the index, the oracle fetches the current price, multiplies by the constituent’s weight, and sums all contributions. The result is divided by the total weight (10,000 bps) to get the weighted-average index value. NAV updates happen continuously as keepers trigger the update_nav instruction.

What happens if Pyth goes down?

Stratum has multiple safeguards for oracle failures:

• Individual feed staleness: If one Pyth feed goes stale, that constituent is excluded from the NAV calculation using its last known weight contribution
• NAV staleness protection: If the overall NAV hasn’t been updated in 24 hours (all feeds stale), all mint/redeem operations are automatically blocked
• Emergency pause: The protocol authority can manually pause operations if needed
• Your tokens are safe: Even during an oracle outage, your S-tokens remain in your wallet and the USDC in the vault is untouched. Operations resume normally once oracle service is restored.

Protocol

Is the code open source?

Yes. All Stratum Protocol smart contracts, SDK, and frontend code are open source and available on GitHub. We believe in transparency and verifiability. Anyone can inspect the code, verify the PDA derivations, and confirm that the protocol operates as documented.

When will $STRAT launch?

Coming soon. $STRAT will launch on pump.fun as a fair launch with no pre-sale and no VC allocation. Follow our official channels for the exact launch date and verified contract address. Beware of scams — only use links from our official website at sxr.network.

Which wallets are supported?

Stratum supports all major Solana wallets:

• Phantom — Most popular Solana wallet
• Solflare — Feature-rich Solana wallet
• Backpack — Multi-chain wallet with xNFT support
• Ledger — Hardware wallet (via Phantom or Solflare)
• Any wallet supporting the Solana Wallet Standard

Can I use S-tokens in other DeFi protocols?

Yes. S-tokens are standard SPL tokens on Solana. They can be transferred, traded on DEXs, used as collateral in lending protocols (subject to those protocols listing them), and integrated into any Solana DeFi application. This composability is a key advantage of Stratum’s on-chain design.

How do I become a keeper?

Keepers are off-chain bots that trigger daily rebalancing and NAV update operations. Anyone can run a keeper — the update_nav instruction is permissionless. Keepers earn $STRAT rewards from the ecosystem allocation for each successful NAV update. Documentation for running a keeper will be published after mainnet launch.