Indexer: Block-Level Accrual

Indexer

Block-Level Indexing

Rosetta’s Indexer computes the state of every tracked vault and market at every block.

The Problem with Event-Based Systems

Most DeFi data infrastructure is event-based: state updates only when transactions occur. Between transactions, data goes stale. But interest accrues every block. A market with no transactions still has borrowers owing more, lenders entitled to more, utilization shifting, and rates adjusting. Event-based systems miss all of this.

What Rosetta Does Differently

Rosetta treats each block as the atomic unit of truth. Instead of waiting for events, the Indexer:

Accrues interest forward: Computes what borrowers owe and lenders are entitled to at the current block, regardless of when the last transaction occurred
Recomputes utilization: Calculates the current ratio of borrowed to supplied assets, reflecting accrued interest
Recalculates rates: Runs the protocol’s IRM logic to determine current Borrow APY and Supply APY
Updates vault state: Rolls up market-level changes to compute current vault positions, PPS, and blended yields
Stores block-level snapshots: Maintains a time series of state at block granularity

Why This Matters

Block-level data enables:

Accurate yield comparison: Compare vaults using current rates, not stale snapshots
Precise routing decisions: The Yield Router acts on real-time data, not outdated signals
Honest APY reporting: Users see what they will actually earn, not what the rate was hours ago
Backtesting with fidelity: Historical analysis uses actual block-by-block state, not interpolated guesses

The Indexer is the foundation that makes intelligent routing possible.

How It Works

Accrual Computation

Interest accrues based on time elapsed and the current borrow rate. For each block, the Indexer computes:

time_elapsed = current_timestamp - last_update_timestamp
interest_factor = exp(borrow_rate * time_elapsed)

total_borrowed = total_borrowed_previous * interest_factor
total_supplied = total_supplied_previous + (total_borrowed - total_borrowed_previous)

Utilization and Rate Recalculation

With updated totals, utilization is recomputed:

utilization = total_borrowed / total_supplied

The Indexer then runs the protocol’s IRM to get current rates. For an adaptive curve IRM:

target_utilization = 0.9
err = (utilization - target_utilization) / target_utilization

*# Curve mechanism*
if err < 0:
    borrow_rate = ((1 - 1/C) * err + 1) * rate_at_target
else:
    borrow_rate = ((C - 1) * err + 1) * rate_at_target

*# Adaptation mechanism*
rate_at_target = rate_at_target_previous * exp(speed * err * time_elapsed)

Where C = 4 (curve steepness) and speed = 50 (adaptation speed). Supply rate derives from borrow rate:

supply_rate = borrow_rate * utilization * (1 - protocol_fee)

APY Conversion

Rates are per-second. To convert to APY:

seconds_per_year = 365 * 24 * 60 * 60
borrow_apy = exp(borrow_rate * seconds_per_year) - 1
supply_apy = exp(supply_rate * seconds_per_year) - 1

For markets and vaults, PPS tracks the value of each share over time:

pps = total_assets / total_shares

As interest accrues, total_assets grows while total_shares remains constant (until deposits/withdrawals), causing PPS to increase.

Vault State Rollup

Vaults hold shares in multiple markets. The Indexer values each position and aggregates:

position_values = []

for market in vault.markets:
    market_pps = market.total_assets / market.total_shares
    position_value = vault.shares_in_market[market] * market_pps
    position_values.append(position_value) *# Add each position*

*# After loop completes, vault_total_assets = sum of all positions*
vault_total_assets = sum(position_values)
vault_pps = vault_total_assets / vault_total_shares

Vault Supply APY is the weighted average of underlying market rates:

weighted_rates = []

for market in vault.markets:
    weight = vault.position_value[market] / vault_total_assets
    weighted_rate = market.supply_apy * weight
    weighted_rates.append(weighted_rate)

vault_supply_apy = sum(weighted_rates)

Block Snapshot Schema

Each block produces a snapshot stored with the following structure:

MarketSnapshot = {
    block_number: 22177570,
    timestamp: 1734537602,
    market_address: "0xd13b...04fc",
    total_supplied: 3484707.2,        # USDC
    total_borrowed: 2665432.8,        # USDC
    utilization: 0.7644,              # 76.44%
    borrow_apy: 0.0668,               # 6.68%
    supply_apy: 0.0511,               # 5.11%
    available_liquidity: 819274.4,   # USDC
    rate_at_target: 0.0542            # 5.42%
}

VaultSnapshot = {
    block_number: 22177570,
    timestamp: 1734537602,
    vault_address: "0x8a86...ea27",
    total_assets: 52953204.18,        # USDC
    total_shares: 51847293.62,        # feUSDC
    pps: 1.0213,
    supply_apy: 0.0465,               # 4.65%
    market_allocations: {
        "kHYPE/USDC": 38590000.0,     # 72.89%
        "WHYPE/USDC": 10950000.0,     # 20.70%
        "UBTC/USDC": 3240000.0,       # 6.13%
        "PT-kHYPE/USDC": 142940.0     # 0.27%
    }
}

Aave Accrual

The Indexer also tracks Aave markets using the Aave V3 accrual model. While the principles are the same — compute state at every block — the mechanics differ from Morpho.

Aave Interest Accrual

Aave tracks cumulative interest via a liquidity index, a monotonically increasing multiplier:

time_elapsed = current_timestamp - last_update_timestamp
linear_rate = variable_borrow_rate * time_elapsed / seconds_per_year

# Liquidity index update (ray math, 10^27 precision)
liquidity_index = liquidity_index_previous * (1 + linear_rate * utilization)

A supplier’s actual balance at any block is:

actual_balance = scaled_balance * liquidity_index

The scaled_balance is set at deposit time and remains constant. As the liquidity index grows, the actual balance increases — this is how Aave accrues yield.

Aave Supply APY

supply_apy = (1 + variable_borrow_rate * utilization / seconds_per_year) ^ seconds_per_year - 1

The Indexer computes this at every block, capturing rate changes that occur between transactions.

Multi-Chain Indexing

The same block-level approach applies across all supported chains. On Base, the Indexer tracks Morpho markets using the same accrual computation described above. Each chain maintains its own snapshot timeline indexed by block number.

What It Tracks

The Indexer maintains continuous state for three entity types: Morpho markets, Morpho vaults, and Aave reserves.

Morpho Markets

For each Morpho lending market, the Indexer tracks:

Field	Description
Total Supplied	Assets deposited by lenders
Total Borrowed	Assets borrowed against collateral
Utilization	Ratio of borrowed to supplied
Borrow APY	Current annualized rate borrowers pay
Supply APY	Current annualized rate lenders earn
Available Liquidity	Withdrawable assets (supplied minus borrowed)
LLTV	Liquidation threshold for the market
Rate At Target	Current IRM target rate (for adaptive models)

Morpho Vaults

For each vault, the Indexer tracks:

Field	Description
Total Assets	Sum of all positions valued in underlying asset
Total Shares	Outstanding vault shares
PPS	Price per share (total assets / total shares)
Supply APY	Weighted average of underlying market rates
Market Allocations	Current distribution across markets
Curator	Entity managing the vault strategy
Deposit Queue	Order in which new deposits are allocated
Withdraw Queue	Order in which withdrawals are sourced

Aave Reserves

For each Aave reserve, the Indexer tracks:

Field	Description
Total Supply	Assets deposited by suppliers
Total Borrowed	Assets borrowed from the pool
Utilization	Ratio of borrowed to supplied
Supply APY	Current annualized rate suppliers earn
Variable Borrow APY	Current annualized rate borrowers pay
Liquidity Index	Cumulative interest multiplier
Available Liquidity	Withdrawable assets
aToken Address	Interest-bearing token contract

Update Frequency

All metrics are recomputed every block. On HyperEVM with ~1 second block times, this means near real-time accuracy. On Base, block times are ~2 seconds. Historical data is retained at block granularity, enabling:

Point-in-time queries at any block height
Time-series analysis of yield trends
Backtesting of routing strategies
Cross-chain yield comparison at synchronized timestamps

Rosetta

Yield Router

Markets & Yields

Risk Intelligence

Reference

Indexer: Block-Level Accrual

Indexer

Block-Level Indexing

The Problem with Event-Based Systems

What Rosetta Does Differently

Why This Matters

How It Works

Accrual Computation

Utilization and Rate Recalculation

APY Conversion

Vault State Rollup

Block Snapshot Schema

Aave Accrual

Aave Interest Accrual

Aave Supply APY

Multi-Chain Indexing

What It Tracks

Morpho Markets

Morpho Vaults

Aave Reserves

Update Frequency

​Indexer

​Block-Level Indexing

​The Problem with Event-Based Systems

​What Rosetta Does Differently

​Why This Matters

​How It Works

​Accrual Computation

​Utilization and Rate Recalculation

​APY Conversion

​Price Per Share (PPS)

​Vault State Rollup

​Block Snapshot Schema

​Aave Accrual

​Aave Interest Accrual

​Aave Supply APY

​Multi-Chain Indexing

​What It Tracks

​Morpho Markets

​Morpho Vaults

​Aave Reserves

​Update Frequency

Indexer

Block-Level Indexing

The Problem with Event-Based Systems

What Rosetta Does Differently

Why This Matters

How It Works

Accrual Computation

Utilization and Rate Recalculation

APY Conversion

Price Per Share (PPS)

Vault State Rollup

Block Snapshot Schema

Aave Accrual

Aave Interest Accrual

Aave Supply APY

Multi-Chain Indexing

What It Tracks

Morpho Markets

Morpho Vaults

Aave Reserves

Update Frequency