# Rates and APY

The **Vault APY** shows how much the value of a vault shares grows over time — similar to earning interest on savings.

This value depends on:

* The **assets** supported in the vault,
* The **strategies** the vault uses,
* The **rebalancing actions** taken by the Vault Manager.

Even though there are many moving parts, **DeFindex Vaults make it easy** to track this performance through the **Vault Price Per Share (VPPS)**.

***

💡 What is Vault Price Per Share?

Just like strategies have a **price per share**, the **vault itself** has a **price per share** that shows how much 1 share of the vault is worth.

This includes:

* All the strategies the vault uses,
* How much is allocated to each strategy,
* And how well each strategy is performing.

So, when the vault earns yield or its strategies grow, the **vault price per share increases**.

***

### 🧮 How to Get the Vault Price Per Share

There are two main ways to calculate it. Both give the same result.

#### ✅ Method 1: Use the Contract Function `get_asset_amounts_per_shares`

```rust
fn get_asset_amounts_per_shares(
        e: Env,
        vault_shares: i128,
    ) -> Result<Vec<i128>, ContractError>;
```

You can get the real-time vault PPS by calling

```rust
get_asset_amounts_per_shares(1_000_000_000_000) // 1 Vault Share is SCALAR_12
```

This function returns a `Vec`of asset amounts per share. Each amount matches the asset at the same index in the vault's asset list.

To calculate the vault share price in a specific pricing currency (e.g. USD):

$$
\text{Vault PPS} = \sum\_{i} \left( \text{Asset Price}\_i \times \text{VAmount}\_i \right)
$$

Where:

* `VAmount_i` = amount of asset `i` per share fasdf
* `Asset Price_i` = price of asset `i` (from an oracle or external source)

**If the vault has only one asset** and you're pricing in that same asset, just use the first value from `get_asset_amounts_per_shares`.

***

#### ✅ Method 2: Use Vault Events

Each time someone deposits or withdraws from the vault, deposit and withdraw events are emitted:

```rust

pub struct VaultWithdrawEvent {
    pub withdrawer: Address,
    pub df_tokens_burned: i128,
    pub amounts_withdrawn: Vec<i128>,
    pub total_supply_before: i128,
    pub total_managed_funds_before: Vec<CurrentAssetInvestmentAllocation>,
}
pub struct VaultDepositEvent {
    pub depositor: Address,
    pub amounts: Vec<i128>,
    pub df_tokens_minted: i128,
    pub total_supply_before: i128,
    pub total_managed_funds_before: Vec<CurrentAssetInvestmentAllocation>,
}
```

Each event includes:

* `total_supply_before` — the number of vault shares before the action
* `total_managed_funds_before` — a list of all asset allocations

Each asset allocation looks like this:

```rust
pub struct CurrentAssetInvestmentAllocation {
    pub asset: Address,
    pub total_amount: i128,
    pub idle_amount: i128,
    pub invested_amount: i128,
    pub strategy_allocations: Vec<StrategyAllocation>,
}
```

To calculate the vault price per share:

$$
\text{Vault PPS} = \frac{\sum \left( \text{Asset Price}\_i \times \text{Total Asset Amount}\_i \right)}{\text{Total Vault Shares}}
$$

If the vault only holds **one asset**, then:

$$
\text{Vault PPS} = \frac{\text{Total Asset Amount}}{\text{Total Supply}}
$$

Where:

* **`Total Asset Amount`** = sum of all units of that one asset held by the vault (from `total_managed_funds_before[0].total_amount`)
* **`Total Supply`** = number of shares before the action (from `total_supply_before`)

### 📈 How to Calculate Vault APY

Once you have the Vault PPS at two different points in time, you can calculate **APY** using the same method as when is calculated for strategies:

$$
\text{pps\_delta} = \frac{\text{PPS}*{\text{now}}}{\text{PPS}*{\text{then}}} - 1
$$

Then annualize it:

$$
\text{Vault APY} = \left(1 + \text{pps\_delta} \right)^{\left( \frac{365.2425}{\text{days}} \right)} - 1
$$

Where `days` is the number of days between the two PPS values.


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.defindex.io/advanced-documentation/10-whitepaper/05-rates-and-apy.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.