# Key Function - harvest ## *harvest* ``` /** * @notice harvest the strategy. This involves accruing profits from the strategy and depositing * user funds to the strategy. The funds are split into their constituents and then distributed * to their appropriate location. * For the shortPosition a perpetual position is opened, for the long position funds are swapped * to the long asset. For the buffer position the funds are deposited to the margin account idle. * @dev only callable by the owner */ function harvest() public onlyOwner { uint256 shortPosition; uint256 longPosition; uint256 bufferPosition; isUnwind = false; mcLiquidityPool.forceToSyncState(); // determine the profit since the last harvest and remove profits from the margin // account to be redistributed uint256 amount; bool loss; if (positions.unitAccumulativeFunding != 0) { (amount, loss) = _determineFee(); } // update the vault with profits/losses accrued and receive deposits uint256 newFunds = vault.update(amount, loss); // combine the funds and check that they are larger than 0 uint256 toActivate = IERC20(want).balanceOf(address(this)); if (toActivate > 0) { // determine the split of the funds and trade for the spot position of long (shortPosition, longPosition, bufferPosition) = _calculateSplit( toActivate ); // deposit the bufferPosition to the margin account _depositToMarginAccount(bufferPosition); // open a short perpetual position and store the number of perp contracts positions.perpContracts += _openPerpPosition(shortPosition, true); } // record incremented positions positions.margin = getMargin(); positions.unitAccumulativeFunding = getUnitAccumulativeFunding(); emit Harvest( positions.perpContracts, IERC20(long).balanceOf(address(this)), positions.margin ); } ``` The harvest function is the strategy's "work" function. It is responsible for running the strategy. ``` /** * @notice determine the funding premiums that have been collected since the last epoch * @return fee the funding rate premium collected since the last epoch * @return loss whether the funding rate was a loss or not */ function _determineFee() internal returns (uint256 fee, bool loss) { int256 feeInt; // get the cash held in the margin cash, funding rates are saved as cash in the margin account int256 newAccFunding = getUnitAccumulativeFunding(); int256 prevAccFunding = positions.unitAccumulativeFunding; int256 livePositions = getMarginPositions(); if (prevAccFunding >= newAccFunding) { // if the margin cash held has gone down then record a loss loss = true; feeInt = ((prevAccFunding - newAccFunding) * -livePositions) / 1e18; fee = uint256(feeInt / DECIMAL_SHIFT); } else { // if the margin cash held has gone up then record a profit and withdraw the excess for redistribution feeInt = ((newAccFunding - prevAccFunding) * -livePositions) / 1e18; uint256 balanceBefore = IERC20(want).balanceOf(address(this)); if (feeInt > 0) { mcLiquidityPool.withdraw(perpetualIndex, address(this), feeInt); } fee = IERC20(want).balanceOf(address(this)) - balanceBefore; } } ``` The harvest will begin by determining the profit/loss since the previous harvest. It will do this by getting the *unitAccumulativeFunding* and getting the difference from the last harvest's *unitAccumulativeFunding*. If the difference is positive then the profits will be withdrawn from the margin account. If the difference is negative then the loss will be determined. ``` /** * @notice function to update the state of the strategy in the vault and pull any funds to be redeposited * @param _amount change in the vault amount sent by the strategy * @param _loss whether the change is negative or not * be the sender * @return toDeposit the amount to be deposited in to the strategy on this update */ function update(uint256 _amount, bool _loss) external onlyStrategy returns (uint256 toDeposit) { // if a loss was recorded then decrease the totalLent by the amount, otherwise increase the totalLent if (_loss) { totalLent -= _amount; } else { _determineProtocolFees(_amount); totalLent += _amount; } // increase the totalLent by the amount of deposits that havent yet been sent to the vault toDeposit = want.balanceOf(address(this)); totalLent += toDeposit; lastUpdate = block.timestamp; emit StrategyUpdate(_amount, _loss, toDeposit); if (toDeposit > 0) { want.approve(strategy, toDeposit); want.safeTransfer(msg.sender, toDeposit); } } ``` Next, the harvest will update the vault of the profit/loss. The vault will update its *totalLent* which is the funds it has lent to the vault; if there is a profit then *totalLent* will increase and the protocol fees will be determined. If there is a loss then *totalLent* will decrease. Finally, funds that have been deposited after the previous harvest will be recorded and transferred to the strategy contract. ``` /** * @notice split an amount of assets into three: * the short position which represents the short perpetual position * the long position which represents the long spot position * the buffer position which represents the funds to be left idle in the margin account * @param _amount the amount to be split in want * @return shortPosition the size of the short perpetual position in want * @return longPosition the size of the long spot position in long * @return bufferPosition the size of the buffer position in want */ function _calculateSplit(uint256 _amount) internal returns ( uint256 shortPosition, uint256 longPosition, uint256 bufferPosition ) { require(_amount > 0, "_calculateSplit: _amount is 0"); // remove the buffer from the amount bufferPosition = (_amount * buffer) / MAX_BPS; // decrement the amount by buffer position _amount -= bufferPosition; // determine the longPosition in want then convert it to long uint256 longPositionWant = _amount / 2; longPosition = _swap(longPositionWant, want, long); // determine the short position shortPosition = _amount - longPositionWant; } ``` The harvest will then calculate the split of the gains (deposits and/or profits) and split them first into the buffer position, then the long position, then the short position. The long position is swapped from the deposit asset to the long asset using a Uniswap v2 or Uniswap v3 interfaced AMM. ``` /** * @notice deposit to the margin account without opening a perpetual position * @param _amount the amount to deposit into the margin account */ function _depositToMarginAccount(uint256 _amount) internal { IERC20(want).approve(address(mcLiquidityPool), _amount); mcLiquidityPool.deposit( perpetualIndex, address(this), int256(_amount) * DECIMAL_SHIFT ); emit DepositToMarginAccount(_amount, perpetualIndex); } ``` The harvest will then deposit the short position and buffer position deposit asset into the strategy's MCDEX margin account. ``` /** * @notice open the perpetual short position on MCDEX * @param _amount the collateral used to purchase the perpetual short position * @return tradeAmount the amount of perpetual contracts opened */ function _openPerpPosition(uint256 _amount, bool deposit) internal returns (int256 tradeAmount) { if (deposit) { // deposit funds to the margin account to enable trading _depositToMarginAccount(_amount); } // get the long asset mark price from the MCDEX oracle (int256 price, ) = oracle.priceTWAPLong(); // calculate the number of contracts (*1e12 because USDC is 6 decimals) int256 contracts = ((int256(_amount) * DECIMAL_SHIFT) * 1e18) / price; int256 longBalInt = -int256(IERC20(long).balanceOf(address(this))); // check that the long and short positions will be equal after the deposit if (-contracts + getMarginPositions() >= longBalInt) { // open short position tradeAmount = mcLiquidityPool.trade( perpetualIndex, address(this), -contracts, price - slippageTolerance, block.timestamp, referrer, tradeMode ); } else { tradeAmount = mcLiquidityPool.trade( perpetualIndex, address(this), -(getMarginPositions() - longBalInt), price - slippageTolerance, block.timestamp, referrer, tradeMode ); } emit PerpPositionOpened(tradeAmount, perpetualIndex, _amount); } ``` The harvest will then open a short perpetual position on MCDEX using the short position collateral. The MCDEX internal oracle is used to determine the number of short contracts to open. Finally, a few parameters are updated and a *harvest* event is emitted. *Fin.*