# Additional rewards \[Capture and distribute extra yield from DeFi incentive programs]

Protocol incentives such as AAVE, MORPHO or ENA are distributed to Vehicle addresses by external reward contracts, outside the deposit and redeem lifecycle. The Interceptor standard is how a contract declares where they should go. The rules are on-chain and declarative; off-chain reward distributors read them and route accordingly, which keeps the splitting free of gas and lets a rule target another chain.

Every Vehicle, MultiVehicle and Conduit exposes `interceptions()` and `setInterceptions()`. A Conduit's rules are independent of the Vehicle it wraps, so a distributor sets its own split without touching the yield source. For reward policy as a distributor, see [Additional rewards](/conduits/rewards).

## Structs

```solidity [Solidity]
struct Interception {
    address asset;              // Reward token; address(0) matches all
    Recipient[] recipients;     // Distribution rules
}

struct Recipient {
    address target;    // Where rewards go
    uint256 shareBps;  // Share in basis points (10000 = 100%)
    uint256 chainId;   // Target chain; 0 matches all
}
```

## Matching

Rules resolve last-match-wins, like firewall rules:

1. Scan `interceptions` and take the **last** entry matching the reward token, exactly or through the `address(0)` wildcard.
2. Inside that entry, for each unique `target`, take the **last** entry matching the current `chainId` or the `0` wildcard.

So you declare a default rule for all tokens, then append overrides for specific ones. Anything unallocated (the gap between the recipients' total `shareBps` and 10,000) passes through to users. A recipient total above 10,000 reverts `InterceptionSharesTooHigh`.

## Policies

An empty array and a 100% recipient are the two ends of the same mechanism.

| Policy | Rule | Who gets what |
|--------|------|---------------|
| Pass-through | Empty `interceptions` array | Users claim 100% of the reward tokens |
| Split | One recipient below 10,000 bps | Operator takes its share, the remainder passes through |
| Capture | One recipient at 10,000 bps | Operator takes everything, typically to sell and reinvest |

Capture is how a MultiVehicle turns incentives into share price: sell the reward tokens, then call `deposit(amount, false)` on the Sector Accounting Engine (role `MULTI_VEHICLE_DEPOSIT`). That raises `totalAssets` without minting shares, so every holder gains, and the proceeds sit in `SectorLib.AVAILABLE` until allocated.

## Configuration

One call sets the whole array. Example: 5% on every token by default, 10% on AAVE on Ethereum mainnet only.

```solidity [Solidity]
Interceptor.Interception[] memory interceptions = new Interceptor.Interception[](2);

// Default rule, all tokens, all chains
interceptions[0] = Interceptor.Interception({
    asset: address(0),
    recipients: new Interceptor.Recipient[](1)
});
interceptions[0].recipients[0] = Interceptor.Recipient({
    target: operatorFeeAddress,
    shareBps: 500,
    chainId: 0
});

// Override for AAVE on mainnet; later entry wins
interceptions[1] = Interceptor.Interception({
    asset: address(AAVE_TOKEN),
    recipients: new Interceptor.Recipient[](1)
});
interceptions[1].recipients[0] = Interceptor.Recipient({
    target: operatorFeeAddress,
    shareBps: 1000,
    chainId: 1
});

multiVehicle.setInterceptions(interceptions);
```

Add entries to the inner `recipients` array to split a policy across several addresses: 300 bps to the operator and 200 to a treasury leaves 9,500 passing through.

## Roles

`setInterceptions` is gated on `VEHICLE_SET_INTERCEPTIONS` for a Vehicle or MultiVehicle and on `CONDUIT_SET_INTERCEPTIONS` for a Conduit, each scoped to the contract whose rules change. `ConduitFactory.spawn` takes an `initialInterceptions` array, so a Conduit can ship with its rules already set.