# YearnDAIStrategy

## Overview

The YearnDAIStrategy contract is a strategy that supplies DAI into a Yearn V3 Vault. It manages conversions between USDCe and DAI through Curve's AtriCrypto zapper and handles decimal scaling between the 6-decimal USDCe and 18-decimal DAI 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 1% 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 between 6 and 18 decimals
2. Converting USDCe to DAI through zapper
3. Depositing DAI 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


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://devs.maxapy.io/maxapy-erc4626/strategies/polygon-usdc.e/yearn/yearndaistrategy.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.
