Architecture

A vault is a smart contract with its own balance sheet. Strategy modules plug into external protocols. A controller coordinates allocations and risk. An internal points token tracks participation, and an in-house keeper bot performs harvesting and rebalancing.

System components.

• Vaults (internal ledger). Custody underlying; maintain balances[address], totalPrincipal, and an accrual index used to credit profits.

• Strategy Adapters. Uniform interfaces for deposit/withdraw/harvest/totalUnderlying; classes: Lending, Looping, DEX CL-LP.

• Controller. Holds target parameters, dynamic weight logic, risk caps, and adapter authorizations.

• Keeper (in-house). Operates harvests/rebalances per policy. No external automation providers.

• Points Token (ERC-20). Transferable token that reflects time- and size-weighted participation.

• UI & Indexers. Read on-chain state and events to visualize TVL, allocations, pending rewards, points, and history.

Supported Assets (Rolling Set)

Initial vaults target HyperEVM-native assets such as HYPE, USDT0, UETH, UBTC, feUSD, wstHYPE, USDe, with additional pairs evaluated as venues and liquidity deepen. Exact availability is reflected in the dapp.

Vault Accounting (Internal Ledger, non ERC-4626)

Each depositor has a number in the vault’s books. Profits are credited by multiplying balances with a moving index. Withdrawing returns the updated balance from the books after any strategy unwinds.

Accrual model. The vault maintains a global accrual index I that grows when profit is realized (harvest). For depositor u:

• On deposit of d at index I_now:

  • Record principal_u += d and entryIndex_u = I_now for the deposited tranche.

  • For multiple tranches, store cumulative principal and a weighted entry index (or maintain a per-tranche array).

  • Credited balance at time t:

    balance_u(t) = principal_u * I(t) / entryIndex_u

    If multiple tranches exist, sum each tranche’s principal * I/entryIndex.

  • On harvest, convert rewards to underlying, then update I as:

    I_new = I_old * (totalAssets_after / totalAssets_before)

    or equivalently, increment I by profit / totalPrincipal_effective, respecting dust and fee deduction.

  • On withdraw of amount w:

    • Compute maxOwed = balance_u(t); redeem min(w, maxOwed); reduce principal_u accordingly by back-solving the principal component removed:

      principal_removed = redeemed_amount * entryIndex_u / I(t)

• Properties.

• No share tokens exist; accounting is purely ledger-based.

• PPS-like behavior emerges via I, which monotonically increases on net profit.

• Rounding is conservative; dust accumulation is normalized during harvests.

• Partial withdrawals reduce principal proportionally to keep future accrual consistent.

Visualization

                ┌───────────────────────────────────────────────────┐
                │                      Vault                        │
                │  - internal ledger (balances, principal)          │
User deposit ──▶│  - global accrual index I                         │───▶ User withdraw
                │  - controller params (weights, caps, guards)      │
                └─────┬──────────────────────────┬──────────────────┘
                      │                          │
                      │ allocate                 │ reallocate
                      ▼                          ▼
            ┌─────────────────┐        ┌─────────────────┐        ┌─────────────────┐
            │  DEX CL-LP      │        │   Lending       │        │   Looping       │
            │  strategy       │        │   strategy      │        │   strategy      │
            └───────┬─────────┘        └──────┬─────────┘        └──────┬─────────┘
                    │ harvest & collect        │ harvest                   │ harvest / delever
                    ▼                          ▼                           ▼
                (fees & emissions)         (interest & rewards)      (carry & emissions)
                    └──────────┬───────────────┬──────────────────────────┘
                               ▼               ▼
                       in-house keeper: claim→swap→fee→index update→redeploy

Glossary

• Accrual Index III: Global multiplier that credits profits to all depositors.

• Credited Balance: Principal × I/entryIndexI/\text{entryIndex}I/entryIndex for each depositor (sum across tranches if used).

• CL-LP: Concentrated-liquidity AMM position within a price range (tick band).

• HF / LTV / CF: Health Factor / Loan-to-Value / Collateral Factor (looping safety metrics).

• Drift: Difference between current price and band mid (for CL-LP) or target allocation weights.

• Uptime {u}: Fraction of time price remains within the active CL-LP band.

• Points: Transferable ERC-20 token that tracks participation; accrues by size×time (boosts optional).

• Referral Override: 5% of a referee’s produced points credited to the referrer (single-level).

• Keeper: In-house automation bot that harvests, rebalances, and enforces safety playbooks.