---
# System prepended metadata

title: 'Curator Studio: Yield Redirector Strategy'

---

# Curator Studio: Yield Redirector Strategy

<div style="font-size:24px;margin-bottom:16px;">
A principal-preserving vault that routes DeFi yield to a designated recipient.
</div>



## Purpose

Curator Studio enables curators to redirect yield from ERC-4626 vaults toward a recipient of choice while preserving the original principal. Instead of compounding yield for depositors, all excess yield is sent directly to a beneficiary, enabling transparent funding of initiatives or protocols.

This design is minimal, modular, and composable, compatible with existing ERC-4626 vaults such as **Morpho, Euler 4626 wrappers,** and **Yearn**. 


## Concept Overview

```
Capital Provider
      │ 1. Deposit Assets
      ▼
YieldRedirector4626 (Wrapper)
      │ 2. Routes Assets
      ▼
Source Vault (ERC-4626)
      │ 3. Generates Yield
      │
      ▼
[Yield Harvest] ──> Recipient / Strategy
```

Key points:
* Deposits represent principal only.
* Yield is not reflected in share price.
* Yield is redirected entirely to a recipient.




## Key Components

### 1. Source Vault (ERC-4626)

* Standard ERC-4626 vault holding principal and generating yield.
* Could be **Morpho, Euler 4626, Yearn**, or any fully ERC-4626-compliant vault.
* `convertToAssets()` reflects current total value including yield.

### 2. Yield Redirector (YieldRedirector4626)

* Wraps the source vault with an ERC-4626 interface.
* Tracks **deposited principal**.
* Harvests yield to a **single recipient**.
* Shares represent claims on principal only.



## Contract

```solidity
contract YieldRedirector4626 is ERC4626, Ownable {
    using SafeERC20 for IERC20;
    
    event Harvest(uint256 amount, address recipient);

    IERC4626 public immutable sourceVault;
    address public yieldRecipient;
    uint256 public principal;

    constructor(
        IERC4626 sourceVault_, 
        address yieldRecipient_
    ) 
        ERC4626(IERC20(sourceVault_.asset()))
        ERC20(
            string(abi.encodePacked("YieldRedirector ", sourceVault_.name())),
            string(abi.encodePacked("yR-", sourceVault_.symbol()))
        )
        Ownable(msg.sender)
    {
        require(yieldRecipient_ != address(0), "Invalid recipient");
        sourceVault = sourceVault_;
        yieldRecipient = yieldRecipient_;

        IERC20(asset()).approve(address(sourceVault_), type(uint256).max);
    }

    function totalAssets() public view override returns (uint256) {
        return principal;
    }

    function surplus() public view returns (uint256) {
        uint256 total = sourceVault.convertToAssets(sourceVault.balanceOf(address(this)));
        return total > principal ? total - principal : 0;
    }

    function harvest() external {
        uint256 amount = surplus();
        require(amount > 0, "No yield available");
        sourceVault.withdraw(amount, yieldRecipient, address(this));
        IStrategy(yieldRecipient).distribute(asset()); // Immediately distribute yield to the recipients
        
        emit Harvest(amount, yieldRecipient);
    }

    function _deposit(
        address caller,
        address receiver,
        uint256 assets,
        uint256 shares
    ) internal override {
        IERC20(asset()).safeTransferFrom(caller, address(this), assets);

        sourceVault.deposit(assets, address(this));
        principal += assets;
        _mint(receiver, shares);

        emit Deposit(caller, receiver, assets, shares);
    }

    function _withdraw(
        address caller,
        address receiver,
        address owner,
        uint256 assets,
        uint256 shares
    ) internal override {
        if (caller != owner) {
            _spendAllowance(owner, caller, shares);
        }

        principal -= assets;
        _burn(owner, shares);
        sourceVault.withdraw(assets, address(this), address(this));
        IERC20(asset()).safeTransfer(receiver, assets);

        emit Withdraw(caller, receiver, owner, assets, shares);
    }

    function setYieldRecipient(address newRecipient) external onlyOwner {
        require(newRecipient != address(0), "Invalid recipient");
        yieldRecipient = newRecipient;
    }
}

```



## How It Works

1. **Deposit Principal**: Users deposit into the redirector. The principal is sent to the source vault.
2. **Track Principal**: Shares represent **only the original deposit**.
3. **Accrue Yield**: Source vault generates yield over time.
4. **Harvest Yield**: Calling `harvest()` withdraws all surplus yield and sends it to the configured `yieldRecipient`.
5. **Principal Preservation**: Deposited principal remains fully intact; only surplus yield is redirected.

## Vault Compatibility

* **Morpho ERC-4626 wrappers** – fully supported
* **Euler 4626 vaults** – fully supported
* **Yearn ERC-4626-compatible vaults** – fully supported

> Must be ERC-4626-compliant, non-rebasing, and fully capitalizing yield. Only supports vaults where yield is realized via asset appreciation (auto-compounding). External reward tokens are not harvested.
