Lending Vaults

Technical reference for the LotusV2Adapter connecting Vault V2 instances to Lotus markets, covering allocation, deallocation, position tracking, and skim.

Lotus Lending Vaults are Vault V2 instances that allocate into Lotus market tranches through the LotusV2Adapter. Vault V2 provides the framework (deposits, withdrawals, allocator workflow, adapter system); the LotusV2Adapter bridges vault allocations to Lotus supply() / withdraw() calls.

---

LotusV2Adapter

One adapter is deployed per vault. It detects the vault's denomination asset on construction, sets approvals to Lotus and the vault, and reports a stable adapter ID for position tracking.

---

Supported positions

A “Lotus position” inside the adapter is defined by:

• marketParams

• trancheIndex

The adapter enforces that the Lotus market's loanToken equals the vault's asset — a vault can only allocate into markets denominated in its own token.

---

Allocation into Lotus tranches

allocate()

Supplies the vault asset into a Lotus tranche. Only the parent vault can call allocate, and data must decode into a LotusPosition. Returns Vault V2 IDs and the allocation delta.

deallocate()

Withdraws from Lotus with shouldAccrueInterest = true and returns the same IDs and delta.

---

Adapter ids

The adapter reports three IDs for each Lotus position: the adapter ID, a collateral token ID, and a position ID derived from marketParams and tranche index.

---

Tracking active positions

The adapter maintains an internal list of active Lotus positions (_lotusPositions). A position is:

• added when its allocation moves from 0 → >0

• removed when its allocation moves from >0 → 0

This list drives efficient iteration: only positions with non-zero allocations are queried, avoiding the cost of scanning all possible market/tranche pairs.

┌─────────────────────────────────────────────────────────────────────┐
│               Adapter Position Tracking                             │
└─────────────────────────────────────────────────────────────────────┘

Position lifecycle in _lotusPositions array:

  [Empty list]
       │
       │ allocate(100, positionA) → allocation 0 → 100
       ▼
  [positionA]  ← ADDED to active positions
       │
       │ allocate(50, positionB) → allocation 0 → 50
       ▼
  [positionA, positionB]  ← ADDED
       │
       │ deallocate(100, positionA) → allocation 100 → 0
       ▼
  [positionB]  ← REMOVED (positionA allocation = 0)
       │
       │ allocate(75, positionA) → allocation 0 → 75
       ▼
  [positionB, positionA]  ← RE-ADDED
       │
       │ deallocate(50, positionB) → allocation 50 → 0
       ▼
  [positionA]  ← REMOVED (positionB allocation = 0)

---

realAssets() calculation

The realAssets() function computes the adapter's total asset value by iterating over all active Lotus positions and converting each position's supply shares to assets at the current exchange rate.

┌─────────────────────────────────────────────────────────────────────┐
│               realAssets() Calculation                               │
└─────────────────────────────────────────────────────────────────────┘

Example: Vault holds USDC, allocates to 3 Lotus market tranches:

┌──────────┬─────────────────────────────┬────────────┬─────────────┐
│ Position │ Market & Tranche            │ Allocation │ Supply      │
│          │                             │ (assets)   │ Shares Held │
├──────────┼─────────────────────────────┼────────────┼─────────────┤
│    A     │ USDC/WETH market, tranche 0 │  10,000    │   9,800     │
│    B     │ USDC/WETH market, tranche 2 │   5,000    │   4,900     │
│    C     │ USDC/WBTC market, tranche 1 │   3,000    │   2,950     │
└──────────┴─────────────────────────────┴────────────┴─────────────┘

  function realAssets() returns (uint256) {
      uint256 total = 0;

      for each position in _lotusPositions:
          shares = Lotus.supplyShares(
              position.marketParams,
              position.trancheIndex,
              address(adapter)
          )
          assets = Lotus.toSupplyAssets(
              position.marketParams,
              position.trancheIndex,
              shares
          )
          total += assets

      return total
  }

  Step-by-step:
    Position A: 9,800 shares → 10,050 assets (gained interest)
    Position B: 4,900 shares →  5,020 assets (gained interest)
    Position C: 2,950 shares →  3,010 assets (gained interest)
                              ──────────
    realAssets() = 18,080 USDC

---

Skimming stray tokens

The adapter includes a skim mechanism to recover tokens that end up in the adapter outside the normal flow.

• the vault owner sets skimRecipient

• only skimRecipient can call skim(token)

• skim(token) transfers the adapter’s full balance of token to skimRecipient

function setSkimRecipient(address newSkimRecipient) external {
    if (msg.sender != IVaultV2(parentVault).owner()) revert NotAuthorized();
    ...
}

function skim(address token) external {
    if (msg.sender != skimRecipient) revert NotAuthorized();
    uint256 balance = IERC20Token(token).balanceOf(address(this));
    IERC20Token(token).transfer(skimRecipient, balance);
}

---

Usage constraints

Usage constraints:

• It must be used with Lotus markets protected against inflation attacks via an initial supply.

• It must not be used with an IRM that can re-enter the parent vault or the adapter.

• Rounding error losses on supply/withdraw are realizable.

• Lotus positions are removed from the tracked list when allocation reaches zero.