ChainIndex

Tokenized index vault that routes user stablecoin deposits into vetted DeFi protocol vaults (ERC-4626), then runs delta-neutral yield strategies (liquid + illiquid) to deliver compounding returns while preserving principal exposure to reputable onchain protocols.

1. What this project is (concept)

An onchain product that:

Categorizes protocols by their onchain reputation (example rule: protocols that have ≥ $5B in Aave reserve-related TVL) and creates an index (e.g., “Stable Protocols”) consisting of those protocol exposures (Ethena, Pendle, Morpho as examples).

Tokenizes exposure so users stake stablecoins (USDC/USDT) → convert to protocol-native stable token AUSD → wrap to sAUSD (ERC-4626) for each protocol allocation.

Mints an index token (ERC-20) representing pro-rata ownership of the pooled assets across all protocol vaults.

Runs active strategies (quant-driven) to generate delta-neutral yield (target 20–40% APY in initial/product marketing) using a mix of liquid yield capture and illiquid structured strategies, while hedging directional risk offchain/onchain.

NOTE: We are not using the Aave Reserves fund we are just tracking data thats it.

1. Why this is valuable

Simplicity for users: one deposit gives diversified exposure to top-tier yield protocols without manual allocation, bridging complexity for mainstream DeFi users.

Composability: ERC-4626 shares and an ERC-20 index token enable plug-and-play integrations (LPs, farms, lending).

Active alpha: quant strategies and hedges can extract additional yield beyond passive deposit APYs.

Reputation filter: by only including protocols with strong onchain signals (e.g., large Aave reserve TVL, audits), the index reduces reliance on any single risky protocol.

1. Core concepts & primitives

AUSD: protocol-native stable ERC-20 used as internal accounting unit (USDC/USDT -> AUSD).

sAUSD: ERC-4626 vault token that represents deposited AUSD into a specific protocol exposure (one sAUSD per protocol).

IndexVault: primary contract that accepts user deposits, calls exchange to produce AUSD, allocates to protocol adapters, and mints IndexToken shares.

ProtocolAdapter: tiny, replaceable contract that abstracts deposit/withdrawal logic for each protocol (Morpho, Pendle, Ethena).

Keeper / Orchestrator: offchain signer + onchain executor that submits signed EIP-712 orders for rebalances and hedges.

Quant Engine: offchain strategy engine that defines hedge sizing, when to take profits, and illiquid strategy triggers.

Reserve Fund: onchain insurance/reserve pool for sudden withdrawals or first-loss coverage.

Eligibility Filter: automated checks (TheGraph/DefiLlama) to ensure only protocols meeting TVL/reserve criteria are included.

1. High-level architecture (components)

Onchain

IndexFactory (deploys indexes)

IndexVault (ERC-20 index token + deposit/redeem)

AUSD (mintable ERC-20 internal stable)

sAUSD (ERC-4626 vault wrapper per protocol)

ProtocolAdapter (one per protocol)

Keeper (executes signed rebalances)

ReserveFund (liquidity for redemptions)

Governance: multisig + timelock, pause/circuit breaker controls

Offchain

Quant Engine (strategy signals, backtests)

Orchestrator/Keeper Relayer (signs orders, handles retries)

Data Stack: The Graph subgraphs, DefiLlama cross-checks, Pyth/Chainlink for prices

Monitoring & Alerting (Prometheus, Sentry, Slack/ops)

1. Exact flows (step-by-step) Deposit flow

User approves IndexVault for USDC/USDT and calls depositFromStable(amount, targetIndex).

IndexVault transferFrom stable -> sends stable into an Exchange/Router contract (or to a MockExchange in MVP).

Exchange swaps/bridges stable -> mints/transfers AUSD to IndexVault.

IndexVault queries IndexFactory/eligibility filter (Aave reserve TVL checks via TheGraph/DefiLlama) to determine active adapters.

IndexVault splits AUSD per-adapter (weights) and transfers to each ProtocolAdapter.

Adapter deposits into sAUSD (ERC-4626) or directly into protocol, receiving protocol shares.

IndexVault mints IndexToken shares to user, proportional to increase in total assets.

Withdraw flow (redeem to AUSD; optionally to stable)

User calls redeemToAUSD(shares); IndexVault computes pro-rata AUSD amount.

IndexVault instructs adapters to withdraw proportional amounts to assemble AUSD.

After gathering AUSD, IndexVault either transfers AUSD to user or calls Exchange to swap AUSD back to stable and transfers stable.

Rebalance / Hedge flow

Quant Engine computes new target exposures and hedge sizes (perps/options/funding swaps).

Orchestrator signs EIP-712 rebalance order and relays to Keeper.

Keeper executes onchain: withdraws from/ deposits to adapters, routes swaps via aggregator (1inch/Uniswap), and opens/adjusts hedges on perp venues (could be through integrated margin connectors).

Transaction emits RebalanceExecuted with details for TheGraph or Ponder indexing and monitoring.

1. Example strategy types (delta neutral)

Liquid strategies

Lend AUSD in Morph-Aave to earn supply APR; short equivalent notional on perp markets (GMX/dYdX) to neutralize price exposure; net funding + supply spread = yield.

Provide concentrated liquidity in stable pairs and capture fees while hedging impermanent risk with perps.

Illiquid strategies

Lock AUSD into fixed-term yield instruments (e.g., structured notes or Pendle PT/YT) that pay higher yields; hedge duration via options or simple funding trades.

Participate in fixed-maturity pools, extract term premium, and borrow against collateral to increase yield (careful with liquidation).

Yield stacking

Claim protocol rewards, swap/reinvest into AUSD, and compound within index.

We built this index fund fully onchain by combining ERC standards with modular vaults. At the core, we created an ERC-20 stable token (AUSD) as our internal accounting unit and wrapped it in an ERC-4626 vault token (sAUSD) for protocol allocations. The IndexVault contract accepts USDC/USDT, mints AUSD, allocates it across protocol adapters (Morpho, Pendle, Ethena in our demo), and mints back an index share token to the depositor.

Each protocol adapter is a lightweight contract that abstracts deposit/withdraw into its target protocol. This modularity made it easy to plug different DeFi protocols under one index without touching vault logic. For yield strategies, we integrated a simple offchain “Quant Engine” that computes allocation/hedging signals and relays signed orders to an onchain Keeper executor. The keeper adjusts allocations or opens hedges through a swap router (1inch/Uniswap).

For data, we relied on Pyth price feeds for accurate stable pricing, and The Graph to index vault events and allocations so our frontend could render live NAV and protocol weights. We also experimented with DefiLlama APIs for TVL checks to auto-filter eligible protocols based on reserve thresholds.

We used Solidity for smart contracts (ERC-20, ERC-4626, adapters, vault), Foundry for testing, and a Next.js + wagmi frontend for user interaction (deposit/redeem flows). Offchain services (Quant Engine + Orchestrator) were built in Node.js with ethers for signing.

Hacky bits: we wrote a mock exchange that instantly swaps USDC/USDT to AUSD 1:1 to simplify the MVP, and a lightweight keeper that just listens to rebalance events and pushes transactions using EIP-712 signatures. This let us simulate full strategy execution without needing to connect to real perp venues at hackathon time.

Overall, the stack is cleanly modular: ERC standards for composability, adapters for flexibility, oracles/indexers for transparency, and a small offchain loop for active management.