# YearnDAILenderStrategy

## Overview

The YearnDAILenderStrategy contract is a strategy that supplies DAI into a Yearn V3 Vault for lending. It manages conversions between USDCe and DAI through Curve's AtriCrypto zapper and handles decimal scaling between tokens.

## Constants

```solidity
ICurveAtriCryptoZapper constant zapper = ICurveAtriCryptoZapper(CURVE_AAVE_ATRICRYPTO_ZAPPER_POLYGON);  // Curve zapper
address public constant dai = DAI_POLYGON;                                                                // DAI address
```

## Functions

### Initialization Functions

#### initialize

```solidity
function initialize(
    IMaxApyVault _vault,
    address[] calldata _keepers,
    bytes32 _strategyName,
    address _strategist,
    IYVaultV3 _yVault
) public virtual override initializer
```

Initializes the strategy with trading limits.

Parameters:

* `_vault`: MaxApy vault address
* `_keepers`: Array of keeper addresses
* `_strategyName`: Name of the strategy
* `_strategist`: Strategist address
* `_yVault`: Yearn V3 vault address

### Core Functions

#### liquidateExact

```solidity
function liquidateExact(uint256 amountNeeded) external override checkRoles(VAULT_ROLE) returns (uint256 loss)
```

Withdraws exact amount to vault with loss calculation.

Parameters:

* `amountNeeded`: Amount to withdraw

Returns:

* `loss`: Amount of realized loss

### View Functions

#### previewLiquidate

```solidity
function previewLiquidate(uint256 requestedAmount) public view override returns (uint256 liquidatedAmount)
```

Simulates withdrawal including losses.

Parameters:

* `requestedAmount`: Amount to withdraw

Returns:

* `liquidatedAmount`: Expected output amount

#### previewLiquidateExact

```solidity
function previewLiquidateExact(uint256 liquidatedAmount) public view override returns (uint256 requestedAmount)
```

Calculates input needed with 1% buffer.

Parameters:

* `liquidatedAmount`: Desired output amount

Returns:

* `requestedAmount`: Required input amount

#### maxLiquidate

```solidity
function maxLiquidate() public view override returns (uint256)
```

Returns maximum withdrawable amount after losses.

Returns:

* Maximum withdrawable amount

#### maxLiquidateExact

```solidity
function maxLiquidateExact() public view override returns (uint256)
```

Returns maximum withdrawable amount with safety margin.

Returns:

* Maximum withdrawable amount before losses

### Internal Core Functions

#### \_invest

```solidity
function _invest(uint256 amount, uint256 minOutputAfterInvestment) internal override returns (uint256 depositedAmount)
```

Invests assets by:

1. Scaling amounts for 18 decimals
2. Converting USDCe to DAI through zapper
3. Depositing into Yearn vault

Parameters:

* `amount`: Amount to invest
* `minOutputAfterInvestment`: Minimum expected shares

Returns:

* `depositedAmount`: Amount of tokens received

#### \_divest

```solidity
function _divest(uint256 shares) internal override returns (uint256 withdrawn)
```

Withdraws assets by:

1. Redeeming from Yearn vault
2. Converting DAI to USDCe through zapper

Parameters:

* `shares`: Amount of shares to withdraw

Returns:

* `withdrawn`: Amount of assets received

### Internal View Functions

#### \_shareValue

```solidity
function _shareValue(uint256 shares) internal view override returns (uint256 _assets)
```

Calculates underlying value including conversion.

Parameters:

* `shares`: Share amount

Returns:

* Underlying asset value

#### \_sharesForAmount

```solidity
function _sharesForAmount(uint256 amount) internal view override returns (uint256 _shares)
```

Calculates shares needed including spot price.

Parameters:

* `amount`: Asset amount

Returns:

* Required shares

#### \_spotPriceDy

```solidity
function _spotPriceDy(uint256 i, uint256 amount) internal view returns (uint256 _spotDy)
```

Calculates spot price conversion without slippage.

Parameters:

* `i`: Direction (0: DAI->USDC, 1: USDC->DAI)
* `amount`: Amount to convert

Returns:

* Converted amount at spot price