436 lines
14 KiB
Solidity
436 lines
14 KiB
Solidity
// SPDX-License-Identifier: MIT
|
|
pragma solidity ^0.8.0;
|
|
|
|
import "@openzeppelin/contracts-upgradeable/token/ERC20/ERC20Upgradeable.sol";
|
|
import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
|
|
import "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol";
|
|
import "@openzeppelin/contracts-upgradeable/utils/ReentrancyGuardUpgradeable.sol";
|
|
import "@openzeppelin/contracts-upgradeable/utils/PausableUpgradeable.sol";
|
|
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
|
|
import "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
|
|
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
|
|
import {AggregatorV3Interface} from "@chainlink/contracts/src/v0.8/shared/interfaces/AggregatorV3Interface.sol";
|
|
|
|
contract YTAssetVault is
|
|
Initializable,
|
|
ERC20Upgradeable,
|
|
UUPSUpgradeable,
|
|
ReentrancyGuardUpgradeable,
|
|
PausableUpgradeable
|
|
{
|
|
using SafeERC20 for IERC20;
|
|
|
|
/// @custom:oz-upgrades-unsafe-allow constructor
|
|
constructor() {
|
|
_disableInitializers();
|
|
}
|
|
|
|
error Forbidden();
|
|
error HardCapExceeded();
|
|
error InvalidAmount();
|
|
error InvalidHardCap();
|
|
error InvalidPrice();
|
|
error InsufficientUSDC();
|
|
error InsufficientYTA();
|
|
error StillInLockPeriod();
|
|
error RequestNotFound();
|
|
error RequestAlreadyProcessed();
|
|
error InvalidBatchSize();
|
|
error InvalidPriceFeed();
|
|
error InvalidChainlinkPrice();
|
|
|
|
address public factory;
|
|
address public manager;
|
|
|
|
uint256 public hardCap;
|
|
uint256 public managedAssets;
|
|
|
|
address public usdcAddress;
|
|
uint8 public usdcDecimals;
|
|
|
|
uint256 public ytPrice;
|
|
uint256 public constant PRICE_PRECISION = 1e30;
|
|
|
|
uint256 public constant CHAINLINK_PRICE_PRECISION = 1e8;
|
|
|
|
uint256 public nextRedemptionTime;
|
|
AggregatorV3Interface internal usdcPriceFeed;
|
|
|
|
struct WithdrawRequest {
|
|
address user;
|
|
uint256 ytAmount;
|
|
uint256 usdcAmount;
|
|
uint256 requestTime;
|
|
uint256 queueIndex;
|
|
bool processed;
|
|
}
|
|
|
|
mapping(uint256 => WithdrawRequest) public withdrawRequests;
|
|
mapping(address => uint256[]) private userRequestIds;
|
|
|
|
uint256 public requestIdCounter;
|
|
|
|
uint256 public processedUpToIndex;
|
|
|
|
uint256 public pendingRequestsCount;
|
|
|
|
event HardCapSet(uint256 newHardCap);
|
|
event ManagerSet(address indexed newManager);
|
|
event AssetsWithdrawn(address indexed to, uint256 amount);
|
|
event AssetsDeposited(uint256 amount);
|
|
event PriceUpdated(uint256 ytPrice, uint256 timestamp);
|
|
event Buy(address indexed user, uint256 usdcAmount, uint256 ytAmount);
|
|
event Sell(address indexed user, uint256 ytAmount, uint256 usdcAmount);
|
|
event NextRedemptionTimeSet(uint256 newRedemptionTime);
|
|
event WithdrawRequestCreated(uint256 indexed requestId, address indexed user, uint256 ytAmount, uint256 usdcAmount, uint256 queueIndex);
|
|
event WithdrawRequestProcessed(uint256 indexed requestId, address indexed user, uint256 usdcAmount);
|
|
event BatchProcessed(uint256 startIndex, uint256 endIndex, uint256 processedCount, uint256 totalUsdcDistributed);
|
|
|
|
modifier onlyFactory() {
|
|
if (msg.sender != factory) revert Forbidden();
|
|
_;
|
|
}
|
|
|
|
modifier onlyManager() {
|
|
if (msg.sender != manager) revert Forbidden();
|
|
_;
|
|
}
|
|
|
|
function initialize(
|
|
string memory _name,
|
|
string memory _symbol,
|
|
address _manager,
|
|
uint256 _hardCap,
|
|
address _usdc,
|
|
uint256 _redemptionTime,
|
|
uint256 _initialYtPrice,
|
|
address _usdcPriceFeed
|
|
) external initializer {
|
|
__ERC20_init(_name, _symbol);
|
|
__UUPSUpgradeable_init();
|
|
__ReentrancyGuard_init();
|
|
__Pausable_init();
|
|
|
|
if (_usdcPriceFeed == address(0)) revert InvalidPriceFeed();
|
|
usdcPriceFeed = AggregatorV3Interface(_usdcPriceFeed);
|
|
usdcAddress = _usdc;
|
|
|
|
usdcDecimals = IERC20Metadata(usdcAddress).decimals();
|
|
|
|
factory = msg.sender;
|
|
manager = _manager;
|
|
hardCap = _hardCap;
|
|
|
|
ytPrice = _initialYtPrice == 0 ? PRICE_PRECISION : _initialYtPrice;
|
|
|
|
nextRedemptionTime = _redemptionTime;
|
|
}
|
|
|
|
function _authorizeUpgrade(address newImplementation) internal override onlyFactory {}
|
|
|
|
function _getUSDCPrice() internal view returns (uint256) {
|
|
(
|
|
/* uint80 roundId */,
|
|
int256 price,
|
|
/* uint256 startedAt */,
|
|
/* uint256 updatedAt */,
|
|
/* uint80 answeredInRound */
|
|
) = usdcPriceFeed.latestRoundData();
|
|
|
|
if (price <= 0) revert InvalidChainlinkPrice();
|
|
|
|
return uint256(price);
|
|
}
|
|
|
|
function _getPriceConversionFactor() internal view returns (uint256) {
|
|
uint8 ytDecimals = decimals();
|
|
|
|
uint256 numerator = (10 ** ytDecimals) * PRICE_PRECISION;
|
|
|
|
uint256 denominator = (10 ** usdcDecimals) * CHAINLINK_PRICE_PRECISION;
|
|
|
|
return numerator / denominator;
|
|
}
|
|
|
|
function setHardCap(uint256 _hardCap) external onlyFactory {
|
|
if (_hardCap < totalSupply()) revert InvalidHardCap();
|
|
hardCap = _hardCap;
|
|
emit HardCapSet(_hardCap);
|
|
}
|
|
|
|
function setManager(address _manager) external onlyFactory {
|
|
manager = _manager;
|
|
emit ManagerSet(_manager);
|
|
}
|
|
|
|
function pause() external onlyFactory {
|
|
_pause();
|
|
}
|
|
|
|
function unpause() external onlyFactory {
|
|
_unpause();
|
|
}
|
|
|
|
function setNextRedemptionTime(uint256 _nextRedemptionTime) external onlyFactory {
|
|
nextRedemptionTime = _nextRedemptionTime;
|
|
emit NextRedemptionTimeSet(_nextRedemptionTime);
|
|
}
|
|
|
|
function updatePrices(uint256 _ytPrice) external onlyFactory {
|
|
if (_ytPrice == 0) revert InvalidPrice();
|
|
|
|
ytPrice = _ytPrice;
|
|
|
|
emit PriceUpdated(_ytPrice, block.timestamp);
|
|
}
|
|
|
|
function depositYT(uint256 _usdcAmount)
|
|
external
|
|
nonReentrant
|
|
whenNotPaused
|
|
returns (uint256 ytAmount)
|
|
{
|
|
if (_usdcAmount == 0) revert InvalidAmount();
|
|
|
|
uint256 usdcPrice = _getUSDCPrice();
|
|
uint256 conversionFactor = _getPriceConversionFactor();
|
|
|
|
ytAmount = (_usdcAmount * usdcPrice * conversionFactor) / ytPrice;
|
|
|
|
if (hardCap > 0 && totalSupply() + ytAmount > hardCap) {
|
|
revert HardCapExceeded();
|
|
}
|
|
|
|
<<<<<<< HEAD
|
|
IERC20(usdcAddress).safeTransferFrom(msg.sender, address(this), _usdcAmount);
|
|
=======
|
|
// 转入USDC
|
|
IERC20(usdcAddress).transferFrom(msg.sender, address(this), _usdcAmount);
|
|
>>>>>>> usdc
|
|
|
|
_mint(msg.sender, ytAmount);
|
|
|
|
emit Buy(msg.sender, _usdcAmount, ytAmount);
|
|
}
|
|
|
|
function withdrawYT(uint256 _ytAmount)
|
|
external
|
|
nonReentrant
|
|
whenNotPaused
|
|
returns (uint256 requestId)
|
|
{
|
|
if (_ytAmount == 0) revert InvalidAmount();
|
|
if (balanceOf(msg.sender) < _ytAmount) revert InsufficientYTA();
|
|
|
|
if (block.timestamp < nextRedemptionTime) {
|
|
revert StillInLockPeriod();
|
|
}
|
|
|
|
uint256 usdcPrice = _getUSDCPrice();
|
|
uint256 conversionFactor = _getPriceConversionFactor();
|
|
|
|
uint256 usdcAmount = (_ytAmount * ytPrice) / (usdcPrice * conversionFactor);
|
|
|
|
_burn(msg.sender, _ytAmount);
|
|
|
|
requestId = requestIdCounter;
|
|
withdrawRequests[requestId] = WithdrawRequest({
|
|
user: msg.sender,
|
|
ytAmount: _ytAmount,
|
|
usdcAmount: usdcAmount,
|
|
requestTime: block.timestamp,
|
|
queueIndex: requestId,
|
|
processed: false
|
|
});
|
|
|
|
userRequestIds[msg.sender].push(requestId);
|
|
|
|
requestIdCounter++;
|
|
|
|
pendingRequestsCount++;
|
|
|
|
emit WithdrawRequestCreated(requestId, msg.sender, _ytAmount, usdcAmount, requestId);
|
|
}
|
|
|
|
function processBatchWithdrawals(uint256 _batchSize)
|
|
external
|
|
nonReentrant
|
|
whenNotPaused
|
|
returns (uint256 processedCount, uint256 totalDistributed)
|
|
{
|
|
if (msg.sender != manager && msg.sender != factory) {
|
|
revert Forbidden();
|
|
}
|
|
|
|
if (_batchSize == 0) revert InvalidBatchSize();
|
|
|
|
uint256 availableUSDC = IERC20(usdcAddress).balanceOf(address(this));
|
|
uint256 startIndex = processedUpToIndex;
|
|
|
|
for (uint256 i = processedUpToIndex; i < requestIdCounter && processedCount < _batchSize; i++) {
|
|
WithdrawRequest storage request = withdrawRequests[i];
|
|
|
|
if (request.processed) {
|
|
continue;
|
|
}
|
|
|
|
if (availableUSDC >= request.usdcAmount) {
|
|
IERC20(usdcAddress).safeTransfer(request.user, request.usdcAmount);
|
|
|
|
request.processed = true;
|
|
|
|
availableUSDC -= request.usdcAmount;
|
|
totalDistributed += request.usdcAmount;
|
|
processedCount++;
|
|
|
|
pendingRequestsCount--;
|
|
|
|
emit WithdrawRequestProcessed(i, request.user, request.usdcAmount);
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (processedCount > 0) {
|
|
for (uint256 i = processedUpToIndex; i < requestIdCounter; i++) {
|
|
if (!withdrawRequests[i].processed) {
|
|
processedUpToIndex = i;
|
|
break;
|
|
}
|
|
if (i == requestIdCounter - 1) {
|
|
processedUpToIndex = requestIdCounter;
|
|
}
|
|
}
|
|
}
|
|
|
|
emit BatchProcessed(startIndex, processedUpToIndex, processedCount, totalDistributed);
|
|
}
|
|
|
|
function getUserRequestIds(address _user) external view returns (uint256[] memory) {
|
|
return userRequestIds[_user];
|
|
}
|
|
|
|
function getRequestDetails(uint256 _requestId) external view returns (WithdrawRequest memory request) {
|
|
if (_requestId >= requestIdCounter) revert RequestNotFound();
|
|
return withdrawRequests[_requestId];
|
|
}
|
|
|
|
function getPendingRequestsCount() external view returns (uint256) {
|
|
return pendingRequestsCount;
|
|
}
|
|
|
|
function getUserPendingRequests(address _user) external view returns (WithdrawRequest[] memory pendingRequests) {
|
|
uint256[] memory requestIds = userRequestIds[_user];
|
|
|
|
uint256 pendingCount = 0;
|
|
for (uint256 i = 0; i < requestIds.length; i++) {
|
|
if (!withdrawRequests[requestIds[i]].processed) {
|
|
pendingCount++;
|
|
}
|
|
}
|
|
|
|
pendingRequests = new WithdrawRequest[](pendingCount);
|
|
uint256 index = 0;
|
|
for (uint256 i = 0; i < requestIds.length; i++) {
|
|
uint256 requestId = requestIds[i];
|
|
if (!withdrawRequests[requestId].processed) {
|
|
pendingRequests[index] = withdrawRequests[requestId];
|
|
index++;
|
|
}
|
|
}
|
|
}
|
|
|
|
function getQueueProgress() external view returns (
|
|
uint256 currentIndex,
|
|
uint256 totalRequests,
|
|
uint256 pendingRequests
|
|
) {
|
|
currentIndex = processedUpToIndex;
|
|
totalRequests = requestIdCounter;
|
|
pendingRequests = pendingRequestsCount;
|
|
}
|
|
|
|
function getTimeUntilNextRedemption() external view returns (uint256 remainingTime) {
|
|
if (block.timestamp >= nextRedemptionTime) {
|
|
return 0;
|
|
}
|
|
return nextRedemptionTime - block.timestamp;
|
|
}
|
|
|
|
function canRedeemNow() external view returns (bool) {
|
|
return block.timestamp >= nextRedemptionTime;
|
|
}
|
|
|
|
function withdrawForManagement(address _to, uint256 _amount) external onlyManager nonReentrant whenNotPaused {
|
|
if (_amount == 0) revert InvalidAmount();
|
|
|
|
uint256 availableAssets = IERC20(usdcAddress).balanceOf(address(this));
|
|
if (_amount > availableAssets) revert InvalidAmount();
|
|
|
|
managedAssets += _amount;
|
|
IERC20(usdcAddress).safeTransfer(_to, _amount);
|
|
|
|
emit AssetsWithdrawn(_to, _amount);
|
|
}
|
|
|
|
function depositManagedAssets(uint256 _amount) external onlyManager nonReentrant whenNotPaused {
|
|
if (_amount == 0) revert InvalidAmount();
|
|
|
|
if (_amount >= managedAssets) {
|
|
managedAssets = 0;
|
|
} else {
|
|
managedAssets -= _amount;
|
|
}
|
|
|
|
<<<<<<< HEAD
|
|
IERC20(usdcAddress).safeTransferFrom(msg.sender, address(this), _amount);
|
|
=======
|
|
// 从manager转入USDC到合约
|
|
IERC20(usdcAddress).transferFrom(msg.sender, address(this), _amount);
|
|
>>>>>>> usdc
|
|
|
|
emit AssetsDeposited(_amount);
|
|
}
|
|
|
|
function totalAssets() public view returns (uint256) {
|
|
return IERC20(usdcAddress).balanceOf(address(this)) + managedAssets;
|
|
}
|
|
|
|
function idleAssets() public view returns (uint256) {
|
|
return IERC20(usdcAddress).balanceOf(address(this));
|
|
}
|
|
|
|
function previewBuy(uint256 _usdcAmount) external view returns (uint256 ytAmount) {
|
|
uint256 usdcPrice = _getUSDCPrice();
|
|
uint256 conversionFactor = _getPriceConversionFactor();
|
|
ytAmount = (_usdcAmount * usdcPrice * conversionFactor) / ytPrice;
|
|
}
|
|
|
|
function previewSell(uint256 _ytAmount) external view returns (uint256 usdcAmount) {
|
|
uint256 usdcPrice = _getUSDCPrice();
|
|
uint256 conversionFactor = _getPriceConversionFactor();
|
|
usdcAmount = (_ytAmount * ytPrice) / (usdcPrice * conversionFactor);
|
|
}
|
|
|
|
function getVaultInfo() external view returns (
|
|
uint256 _totalAssets,
|
|
uint256 _idleAssets,
|
|
uint256 _managedAssets,
|
|
uint256 _totalSupply,
|
|
uint256 _hardCap,
|
|
uint256 _usdcPrice,
|
|
uint256 _ytPrice,
|
|
uint256 _nextRedemptionTime
|
|
) {
|
|
_usdcPrice = _getUSDCPrice();
|
|
_totalAssets = totalAssets();
|
|
_idleAssets = idleAssets();
|
|
_managedAssets = managedAssets;
|
|
_totalSupply = totalSupply();
|
|
_hardCap = hardCap;
|
|
_ytPrice = ytPrice;
|
|
_nextRedemptionTime = nextRedemptionTime;
|
|
}
|
|
|
|
uint256[50] private __gap;
|
|
} |