> ## Documentation Index
> Fetch the complete documentation index at: https://getequity.io/docs/llms.txt
> Use this file to discover all available pages before exploring further.

# Yield & Accrual

> How debt and fund tokens earn: the price accretes every second, balances never change, and nothing is paid on a schedule.

GetEquity's debt and fund tokens are **accrual tokens**. They earn by becoming worth more,
not by paying anything out.

> [!WARNING]
>
> **There are no coupons.** Nothing is transferred to you on a schedule, and there is nothing
> to claim. Earlier versions of these contracts paid periodic interest; that path was removed.
> If you have integration code calling `calculatePayout()` or `claimPayout()`, those functions
> no longer exist.

## The model

Your **balance never changes**. Buy 1,000 units and you hold 1,000 units for the life of the
instrument. What moves is the price the Market quotes for that asset:

```
price(t) = checkpointPrice + checkpointPrice x rateBps / 10000 x elapsed / 365 days
```

So a holding is worth `balance x price`, and that figure grows every second with no
transaction, no gas and no action from you.

Three properties worth knowing:

* **Simple interest, pro-rated by the second.** It does **not** compound between checkpoints.
  A rate change re-checkpoints at the price accrued so far, which is the only point where
  earlier accrual folds into the base.
* **Accrual stops at maturity.** A matured note does not keep earning. Assets with no maturity
  — funds and equity — accrue indefinitely.
* **A rate of 0 means no accrual.** Equity sits flat by design.

## Which instruments accrue

| `investmentType` | Maturity | Accrues | How you exit |
| - | - | - | - |
| `Debt` | dated, from its tenor | yes | sell any time, or `redeemPrincipal()` after maturity |
| `Fund` | none — perpetual | yes | sell on the Market |
| `Equity` | none | no | sell on the Market |

An equity cannot be given a rate: `set_rate` refuses one unless the instrument's own
`interest_rate_bps` (recorded on the token at mint) is non-zero, so the table is enforced on
chain rather than being a convention. Note the test is the DECLARED RATE, not maturity — a fund
is perpetual and accrues anyway, so maturity would be the wrong question.

The rate a holder earns is the **Market's** rate. The token's `interest_rate_bps` is the
instrument's declared rate: set at mint, and restated by the multisig when a rate is reset, in
the same proposal as the Market change. Whether an instrument accrues at all cannot change after
mint — a declared rate can move between non-zero values, but never to or from 0.

## Reading the value

The price lives on the **Market**, not on the token. Read it there.

> [!WARNING]
>
> **Do not use the rounded price for anything that matters.** Both chains expose a price
> floored to whole hundredths of the payout token — `currentPrice()` on EVM, `price_cents` on
> Solana. On a low-priced asset that figure cannot move for weeks while the value genuinely
> accrues: a 1.00 note at 16.5% takes about **22 days** to move by one hundredth. The accrual
> underneath is carried at far finer precision and **is** paid in full — only the display value
> is rounded.
>
> On Solana it is worse: `price_cents` is only rewritten when a checkpoint is taken, and a
> fixed-rate note has no writes for its whole life, so it never moves at all.

### Ethereum (Base)

```js theme={null}
// Exact, and net of fees — what you would actually receive. Prefer this.
const [gross, fee, net] = await market.calculateSellPayout(token, amount);

// The raw accrual state, if you want to compute or verify it yourself.
const { priceScaled, at, rate, maturity } = await market.getCheckpoint(token);
```

### Solana

There is no oracle program to call — everything needed is on the `Asset` PDA
(`["asset", mint]` under `rwa_market`), so any consumer can compute the price from the account:

| Field | Meaning |
| - | - |
| `checkpoint_price_scaled` | base price, at hundredths x 1e18 |
| `checkpoint_at` | unix seconds the base was taken; accrual runs from here |
| `rate_bps` | signed annual rate; 0 = no accrual |
| `maturity_ts` | accrual stops here; 0 = perpetual |

```
base    = checkpoint_price_scaled != 0
            ? checkpoint_price_scaled
            : price_cents * 1e18          # never checkpointed - see below
elapsed = min(now, maturity_ts or now) - checkpoint_at
price   = base + base * rate_bps * elapsed / (10_000 * 365 days)
```

> [!WARNING]
>
> **`checkpoint_price_scaled` is 0 for every asset listed before accrual shipped**, which today
> means both live mainnet assets. It is not a price of zero — it means no checkpoint has been
> taken, and the stored `price_cents` is the price. Omit the fallback and you will read DPRI as
> worthless. The program's own reader has this branch; a consumer reimplementing the arithmetic
> must have it too.
>
> `rate_bps == 0` also returns `base` immediately, before `checkpoint_at` or `maturity_ts` are
> consulted at all — so an asset with no rate needs none of them.

An on-chain program can skip the arithmetic by depending on the `rwa_market` crate and calling
`rwa_market::current_price_scaled(&asset, now)` — the same function every pricing path inside
the program uses.

## What the price is denominated in

**Hundredths of the asset's own payout token — not dollars.** Read `payoutToken()` on EVM or
`payout_mint` from the `Asset` PDA on Solana, and label it wherever you display it. GetEquity's
assets are currently quoted in **cNGN**, so a price of `100` means ₦1.00. Reading that as
\$1.00 is a \~1,500x error.

The payout token is also the settlement currency: it is what you spend to buy, receive when
you sell, and are paid in at redemption.

## Realising the value

**1. Sell on the Market**

Available at any time, at the accreted price less the asset's fee. This works for every
instrument type, including perpetual funds.

**2. Redeem at maturity**

Only for assets with a maturity, and **only after** it passes. Self-service — you call it
yourself, nothing is pushed to you. Pays principal plus all accrued interest in one
transfer, gross, with no fee charged at maturity.

```js theme={null}
await rwaToken.redeemPrincipal();   // EVM
```

It returns `0` and does nothing for a perpetual asset.

**3. Issuer wind-down**

The issuer may retire an asset early — a prepayment, or a default. Every holder is burned
and paid at a single snapshot price, and trading halts when it begins. You do not need to
call anything.

## Integrating a price feed

If you are building a pool, a lending market or a structured product on top of one of these
assets, you need a price that tracks accrual — a constant-product pool priced off its own
reserves will be arbitraged against the accreted value continuously, at the liquidity
provider's expense.

Pair the asset against **its own payout token**. The Market prices in that token, so the feed
and the pool agree with no FX leg. Pairing against anything else needs a second rate between
the payout token and the other side.

> [!NOTE]
>
> Talk to us before integrating. Feeds are provisioned per asset and we will point you at the
> right one for the chain you are on.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.