> ## 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.
**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 |
## Reading the value
The price lives on the **Market**, not on the token. Read it there.
**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 |
```
elapsed = min(now, maturity_ts or now) - checkpoint_at
price = checkpoint_price_scaled
+ checkpoint_price_scaled * rate_bps * elapsed / (10_000 * 365 days)
```
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
Available at any time, at the accreted price less the asset's fee. This works for every
instrument type, including perpetual funds.
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.
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.
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.