> For the complete documentation index, see [llms.txt](https://knox-fi.gitbook.io/docs/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://knox-fi.gitbook.io/docs/core-concepts.md).

# Core Concepts

This page covers the fundamental building blocks of Knox Protocol: tranches, pool lifecycle, and the priority waterfall system.

### The Three Tranche Types

#### Senior Tranche

Purpose: Guaranteed fixed returns with absolute priority

Key Characteristics:

* Receives a pre-agreed APY (e.g., 5%) regardless of market performance
* Has absolute priority over all pool assets at settlement
* Capacity-constrained by collateral from spectrum + junior tranches
* Only loses money in catastrophic scenarios where all subordinate tranches are fully wiped out

Share Pricing Model:

`shares =compoundAssets(deposit, rSenior, timeRemaining, poolPeriod)`

Early depositors receive more shares to reflect their longer holding period. At maturity, if the senior tranche is fully paid, 1 share = 1 asset.

Example: A deposit of 100 USDC at day 0 in a 365-day pool with 5% APY yields

`100 × 1.05 = 105`

shares. The same deposit at day 183 yields

`100 × 1.05^(182/365) ≈ 102.47`

shares.

#### Spectrum Tranches

Purpose: Customizable risk/reward profiles with capped yields

Key Characteristics:

* Each tranche has a specific APY cap chosen from a configurable grid (e.g., 5.5%, 6.0%, 6.5%, ... 20%)
* Paid in waterfall order: lowest rate → highest rate
* Lower caps = safer (paid earlier, less loss absorption)
* Higher caps = more upside potential but absorb more losses
* Created lazily on-demand via EIP-1167 minimal proxies

Share Pricing Model:

`shares =compoundAssets(deposit, apyCap, timeRemaining, poolPeriod)`

Same compounding mechanism as senior — early deposits get more shares.

Grid Configuration:

With

`rSenior = 5%`

,

`rMaxSpectrum = 20%`

, and

`gridStep = 0.5%`

, available rates are:

`5.5%, 6.0%, 6.5%, 7.0%, ... 19.5%, 20.0%`

The first deposit at any grid point creates that tranche's vault. Subsequent deposits use the existing vault.

#### Junior Tranche

Purpose: Maximum upside potential in exchange for first-loss absorption

Key Characteristics:

* Receives variable, residual yield — everything left after senior, spectrum, and protocol fee
* Absorbs losses first before any impact reaches spectrum or senior
* Captures all upside above the highest spectrum cap
* No capacity constraints (provides collateral for senior)

Share Pricing Model:

`shares =(deposit × totalSupply)/juniorTrancheCurrentValue()`

Standard ERC4626 proportional shares. First depositor receives

`deposit + 1`

shares to prevent inflation attacks.

Value Calculation: Junior value is always computed as a residual via the full waterfall — it's whatever remains after all other tranches are satisfied.

### Pool Lifecycle States

{% stepper %}
{% step %}

### DEPLOYED

Duration: Instantaneous (same transaction as deployment)

What Happens:

* SpectrumFactory clones accountant + senior vault + junior vault via EIP-1167
* `initialize()` is called, setting all parameters
* Immediately transitions to ACTIVE
* Spectrum vaults are NOT created yet (lazy creation)

User Actions: None
{% endstep %}

{% step %}

### ACTIVE

Duration: From deployment until maturity (`tStart + dPeriod`)

What Happens:

* Deposits open via three paths:

  Router (primary):

  * `KnoxRouter.depositSeniorSpectrum()`
  * `/`
  * `depositSpectrumTranche()`
  * `/`
  * `depositJuniorSpectrum()`

  Accountant: Direct calls to

  * `SpectrumAccountant.depositSenior()`
  * `/`
  * `depositSpectrum()`
  * `/`
  * `depositJunior()`

  Vault: ERC4626

  * `vault.deposit()`
  * on existing vaults
* Capital is deployed to underlying market via allocator
* Withdrawals are blocked

Constraints:

* Senior deposits capped by `seniorCapacity()` (based on subordinate collateral)
* Total deposits capped by `cMaxTotalDeposits`
* Spectrum rates must be on the grid
* No deposits after maturity

User Actions: Deposit into chosen tranche(s)
{% endstep %}

{% step %}

### REDEEMED

Duration: From first redemption call until all market positions are claimed

What Happens:

* Anyone calls `redeemShares()` (permissionless)
* For synchronous allocators: immediate redemption, moves directly to SETTLED
* For asynchronous allocators:
  * `requestRedeem()` initiates cooldown period
  * Returns `bytes32 exitHandle`
  * tracked in `pendingExitHandles`
* Anyone can call `claimRedeemedAssets()` to claim ready exits
* When all exits claimed, auto-transitions to SETTLED

User Actions: Wait for redemption to complete (no user action required)

Monitoring:

* `maxPendingExitUnlockAt()` shows latest cooldown timestamp
  {% endstep %}

{% step %}

### SETTLED

Duration: Permanent final state

What Happens:

* `settlePool()` executes the waterfall distribution
* Each tranche vault receives its final asset balance
* Vaults become standard ERC4626 for withdrawals

User Actions: Call `vault.redeem()` to withdraw proportional share

Special Behavior: Last redeemer of each tranche receives entire remaining balance (prevents rounding dust)
{% endstep %}
{% endstepper %}

### Holding Period Impact

Deposits at different times earn proportionally different returns:

| Deposit Day | Pool Period | Holding Period | Return Multiple (5% APY) |
| ----------- | ----------- | -------------- | ------------------------ |
| Day 0       | 90 days     | 90 days        | 1.0121 (1.21%)           |
| Day 30      | 90 days     | 60 days        | 1.0081 (0.81%)           |
| Day 60      | 90 days     | 30 days        | 1.0040 (0.40%)           |
| Day 89      | 90 days     | 1 day          | 1.0001 (0.01%)           |

This is encoded in share pricing via compounding:

`(1 + APY)^(daysHeld / 365)`

### Key Takeaways

* Tranche hierarchy: Senior (safest) → Spectrum low-to-high → Junior (riskiest)
* Share pricing: Senior & spectrum use compounding based on time-in-pool; junior uses standard ERC4626
* Lifecycle: Deposits during ACTIVE → Redemption after maturity → Settlement → Withdrawals
* Time matters: Earlier deposits earn more due to longer compounding period
* Lazy creation: Spectrum vaults created on first deposit at each grid rate