1040 lines
34 KiB
Solidity
1040 lines
34 KiB
Solidity
// SPDX-License-Identifier: MIT
|
||
pragma solidity ^0.8.0;
|
||
|
||
import "forge-std/Test.sol";
|
||
import "../contracts/ytVault/YTAssetVault.sol";
|
||
import "../contracts/ytVault/YTAssetFactory.sol";
|
||
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
|
||
import "@openzeppelin/contracts/proxy/ERC1967/ERC1967Proxy.sol";
|
||
import {AggregatorV3Interface} from "@chainlink/contracts/src/v0.8/shared/interfaces/AggregatorV3Interface.sol";
|
||
|
||
// Mock USDC token for testing (18 decimals like on BSC)
|
||
contract MockUSDC is ERC20 {
|
||
constructor() ERC20("USD Coin", "USDC") {
|
||
_mint(msg.sender, 100000000 * 1e18); // 铸造1亿USDC用于测试
|
||
}
|
||
|
||
function mint(address to, uint256 amount) external {
|
||
_mint(to, amount);
|
||
}
|
||
}
|
||
|
||
// Mock Chainlink Price Feed
|
||
contract MockChainlinkPriceFeed is AggregatorV3Interface {
|
||
int256 private _price;
|
||
uint8 private _decimals;
|
||
|
||
constructor(int256 initialPrice) {
|
||
_price = initialPrice;
|
||
_decimals = 8; // Chainlink standard
|
||
}
|
||
|
||
function decimals() external view override returns (uint8) {
|
||
return _decimals;
|
||
}
|
||
|
||
function description() external pure override returns (string memory) {
|
||
return "Mock USDC/USD Price Feed";
|
||
}
|
||
|
||
function version() external pure override returns (uint256) {
|
||
return 1;
|
||
}
|
||
|
||
function getRoundData(uint80)
|
||
external
|
||
view
|
||
override
|
||
returns (
|
||
uint80 roundId,
|
||
int256 answer,
|
||
uint256 startedAt,
|
||
uint256 updatedAt,
|
||
uint80 answeredInRound
|
||
)
|
||
{
|
||
return (0, _price, block.timestamp, block.timestamp, 0);
|
||
}
|
||
|
||
function latestRoundData()
|
||
external
|
||
view
|
||
override
|
||
returns (
|
||
uint80 roundId,
|
||
int256 answer,
|
||
uint256 startedAt,
|
||
uint256 updatedAt,
|
||
uint80 answeredInRound
|
||
)
|
||
{
|
||
return (0, _price, block.timestamp, block.timestamp, 0);
|
||
}
|
||
|
||
// Helper function to update price in tests
|
||
function updatePrice(int256 newPrice) external {
|
||
_price = newPrice;
|
||
}
|
||
}
|
||
|
||
contract VaultTest is Test {
|
||
YTAssetFactory public factory;
|
||
YTAssetVault public vaultImplementation;
|
||
YTAssetVault public vault;
|
||
MockUSDC public usdc;
|
||
MockChainlinkPriceFeed public usdcPriceFeed;
|
||
|
||
address public owner;
|
||
address public manager;
|
||
address public user1;
|
||
address public user2;
|
||
|
||
// 常量
|
||
uint256 constant PRICE_PRECISION = 1e30;
|
||
uint256 constant CHAINLINK_PRECISION = 1e8;
|
||
uint256 constant INITIAL_USDC_PRICE = 1e8; // $1.00 in Chainlink format (1e8)
|
||
uint256 constant INITIAL_YT_PRICE = 1e30; // 1.0 in PRICE_PRECISION
|
||
uint256 constant HARD_CAP = 1000000 * 1e18; // 100万YT
|
||
|
||
event VaultCreated(
|
||
address indexed vault,
|
||
address indexed manager,
|
||
string name,
|
||
string symbol,
|
||
uint256 hardCap,
|
||
uint256 index
|
||
);
|
||
event Buy(address indexed user, uint256 usdcAmount, uint256 ytAmount);
|
||
event Sell(address indexed user, uint256 ytAmount, uint256 usdcAmount);
|
||
event PriceUpdated(uint256 ytPrice, uint256 timestamp);
|
||
event AssetsWithdrawn(address indexed to, uint256 amount);
|
||
event AssetsDeposited(uint256 amount);
|
||
event HardCapSet(uint256 newHardCap);
|
||
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);
|
||
|
||
function setUp() public {
|
||
// 设置测试账户
|
||
owner = address(this);
|
||
manager = makeAddr("manager");
|
||
user1 = makeAddr("user1");
|
||
user2 = makeAddr("user2");
|
||
|
||
// 部署Mock USDC (18 decimals)
|
||
usdc = new MockUSDC();
|
||
|
||
// 部署Mock Chainlink Price Feed
|
||
usdcPriceFeed = new MockChainlinkPriceFeed(int256(INITIAL_USDC_PRICE));
|
||
|
||
// 部署实现合约
|
||
vaultImplementation = new YTAssetVault();
|
||
|
||
// 部署并初始化Factory
|
||
YTAssetFactory factoryImpl = new YTAssetFactory();
|
||
bytes memory factoryInitData = abi.encodeWithSelector(
|
||
YTAssetFactory.initialize.selector,
|
||
address(vaultImplementation),
|
||
HARD_CAP // 默认硬顶
|
||
);
|
||
ERC1967Proxy factoryProxy = new ERC1967Proxy(address(factoryImpl), factoryInitData);
|
||
factory = YTAssetFactory(address(factoryProxy));
|
||
|
||
// 给测试用户分配USDC
|
||
usdc.transfer(user1, 100000 * 1e18); // 10万USDC
|
||
usdc.transfer(user2, 100000 * 1e18); // 10万USDC
|
||
usdc.transfer(manager, 100000 * 1e18); // 10万USDC给manager
|
||
}
|
||
|
||
function _createVault() internal returns (YTAssetVault) {
|
||
uint256 redemptionTime = block.timestamp + 30 days;
|
||
|
||
address vaultAddr = factory.createVault(
|
||
"YT-A Token",
|
||
"YT-A",
|
||
manager,
|
||
HARD_CAP,
|
||
address(usdc),
|
||
redemptionTime,
|
||
INITIAL_YT_PRICE,
|
||
address(usdcPriceFeed)
|
||
);
|
||
|
||
return YTAssetVault(vaultAddr);
|
||
}
|
||
|
||
function test_01_FactoryInitialization() public view {
|
||
assertEq(factory.vaultImplementation(), address(vaultImplementation));
|
||
assertEq(factory.defaultHardCap(), HARD_CAP);
|
||
assertEq(factory.owner(), owner);
|
||
}
|
||
|
||
function test_02_CreateVault() public {
|
||
uint256 redemptionTime = block.timestamp + 30 days;
|
||
|
||
vm.expectEmit(false, true, false, true);
|
||
emit VaultCreated(
|
||
address(0), // vault地址未知，所以用0
|
||
manager,
|
||
"YT-A Token",
|
||
"YT-A",
|
||
HARD_CAP,
|
||
0 // 第一个vault，索引为0
|
||
);
|
||
|
||
address vaultAddr = factory.createVault(
|
||
"YT-A Token",
|
||
"YT-A",
|
||
manager,
|
||
HARD_CAP,
|
||
address(usdc),
|
||
redemptionTime,
|
||
INITIAL_YT_PRICE,
|
||
address(usdcPriceFeed)
|
||
);
|
||
|
||
vault = YTAssetVault(vaultAddr);
|
||
|
||
// 验证vault基本信息
|
||
assertEq(vault.name(), "YT-A Token");
|
||
assertEq(vault.symbol(), "YT-A");
|
||
assertEq(vault.manager(), manager);
|
||
assertEq(vault.hardCap(), HARD_CAP);
|
||
assertEq(vault.usdcAddress(), address(usdc));
|
||
assertEq(vault.ytPrice(), INITIAL_YT_PRICE);
|
||
assertEq(vault.nextRedemptionTime(), redemptionTime);
|
||
assertEq(vault.factory(), address(factory));
|
||
assertEq(vault.usdcDecimals(), 18); // BSC USDC uses 18 decimals
|
||
|
||
// 验证factory记录
|
||
assertEq(factory.getVaultCount(), 1);
|
||
assertTrue(factory.isVault(vaultAddr));
|
||
}
|
||
|
||
function test_03_CreateVaultWithCustomPrice() public {
|
||
uint256 customYtPrice = 1020000000000000000000000000000; // 1.02
|
||
uint256 redemptionTime = block.timestamp + 60 days;
|
||
|
||
address vaultAddr = factory.createVault(
|
||
"YT-B Token",
|
||
"YT-B",
|
||
manager,
|
||
HARD_CAP,
|
||
address(usdc),
|
||
redemptionTime,
|
||
customYtPrice,
|
||
address(usdcPriceFeed)
|
||
);
|
||
|
||
YTAssetVault customVault = YTAssetVault(vaultAddr);
|
||
|
||
assertEq(customVault.ytPrice(), customYtPrice);
|
||
}
|
||
|
||
function test_04_CreateVaultWithZeroPrice() public {
|
||
// 传入0价格应该使用默认值
|
||
uint256 redemptionTime = block.timestamp + 30 days;
|
||
|
||
address vaultAddr = factory.createVault(
|
||
"YT-C Token",
|
||
"YT-C",
|
||
manager,
|
||
HARD_CAP,
|
||
address(usdc),
|
||
redemptionTime,
|
||
0, // 使用默认价格
|
||
address(usdcPriceFeed)
|
||
);
|
||
|
||
YTAssetVault defaultVault = YTAssetVault(vaultAddr);
|
||
|
||
assertEq(defaultVault.ytPrice(), PRICE_PRECISION); // 1.0
|
||
}
|
||
|
||
function test_05_CannotCreateVaultWithZeroManager() public {
|
||
vm.expectRevert(YTAssetFactory.InvalidAddress.selector);
|
||
factory.createVault(
|
||
"YT-D Token",
|
||
"YT-D",
|
||
address(0), // 无效的manager地址
|
||
HARD_CAP,
|
||
address(usdc),
|
||
block.timestamp + 30 days,
|
||
INITIAL_YT_PRICE,
|
||
address(usdcPriceFeed)
|
||
);
|
||
}
|
||
|
||
function test_06_CannotCreateVaultWithInvalidPriceFeed() public {
|
||
vm.expectRevert(YTAssetVault.InvalidPriceFeed.selector);
|
||
factory.createVault(
|
||
"YT-E Token",
|
||
"YT-E",
|
||
manager,
|
||
HARD_CAP,
|
||
address(usdc),
|
||
block.timestamp + 30 days,
|
||
INITIAL_YT_PRICE,
|
||
address(0) // 无效的价格feed
|
||
);
|
||
}
|
||
|
||
function test_07_CreateVaultOnlyOwner() public {
|
||
vm.prank(user1);
|
||
vm.expectRevert(abi.encodeWithSignature("OwnableUnauthorizedAccount(address)", user1));
|
||
factory.createVault(
|
||
"YT-E Token",
|
||
"YT-E",
|
||
manager,
|
||
HARD_CAP,
|
||
address(usdc),
|
||
block.timestamp + 30 days,
|
||
INITIAL_YT_PRICE,
|
||
address(usdcPriceFeed)
|
||
);
|
||
}
|
||
|
||
function test_08_DepositYT() public {
|
||
vault = _createVault();
|
||
|
||
uint256 depositAmount = 1000 * 1e18; // 1000 USDC
|
||
uint256 expectedYtAmount = 1000 * 1e18; // 价格1:1，获得1000 YT
|
||
|
||
// 授权
|
||
vm.startPrank(user1);
|
||
usdc.approve(address(vault), depositAmount);
|
||
|
||
// 预览购买
|
||
uint256 previewAmount = vault.previewBuy(depositAmount);
|
||
assertEq(previewAmount, expectedYtAmount);
|
||
|
||
// 存款
|
||
vm.expectEmit(true, false, false, true);
|
||
emit Buy(user1, depositAmount, expectedYtAmount);
|
||
|
||
uint256 ytReceived = vault.depositYT(depositAmount);
|
||
vm.stopPrank();
|
||
|
||
// 验证结果
|
||
assertEq(ytReceived, expectedYtAmount);
|
||
assertEq(vault.balanceOf(user1), expectedYtAmount);
|
||
assertEq(vault.totalSupply(), expectedYtAmount);
|
||
assertEq(usdc.balanceOf(address(vault)), depositAmount);
|
||
assertEq(vault.totalAssets(), depositAmount);
|
||
assertEq(vault.idleAssets(), depositAmount);
|
||
}
|
||
|
||
function test_09_DepositYTWithDifferentPrices() public {
|
||
vault = _createVault();
|
||
|
||
// 更新YT价格为 1.02，USDC保持 $1.00
|
||
factory.updateVaultPrices(
|
||
address(vault),
|
||
1020000000000000000000000000000 // 1.02
|
||
);
|
||
|
||
uint256 depositAmount = 1000 * 1e18; // 1000 USDC
|
||
// ytAmount = 1000 USDC * $1.00 / $1.02 = 980.392156862745098039 YT
|
||
// 使用公式: ytAmount = depositAmount * usdcPrice * conversionFactor / ytPrice
|
||
// conversionFactor = 10^18 * 10^30 / (10^18 * 10^8) = 10^22
|
||
uint256 expectedYtAmount = (depositAmount * INITIAL_USDC_PRICE * 1e22) / 1020000000000000000000000000000;
|
||
|
||
vm.startPrank(user1);
|
||
usdc.approve(address(vault), depositAmount);
|
||
uint256 ytReceived = vault.depositYT(depositAmount);
|
||
vm.stopPrank();
|
||
|
||
// 精确验证计算结果
|
||
assertEq(ytReceived, expectedYtAmount);
|
||
assertEq(ytReceived, 980392156862745098039); // 约980.39 YT
|
||
}
|
||
|
||
function test_10_DepositYTMultipleUsers() public {
|
||
vault = _createVault();
|
||
|
||
uint256 amount1 = 1000 * 1e18;
|
||
uint256 amount2 = 2000 * 1e18;
|
||
|
||
// User1存款
|
||
vm.startPrank(user1);
|
||
usdc.approve(address(vault), amount1);
|
||
vault.depositYT(amount1);
|
||
vm.stopPrank();
|
||
|
||
// User2存款
|
||
vm.startPrank(user2);
|
||
usdc.approve(address(vault), amount2);
|
||
vault.depositYT(amount2);
|
||
vm.stopPrank();
|
||
|
||
// 验证余额
|
||
assertEq(vault.balanceOf(user1), amount1);
|
||
assertEq(vault.balanceOf(user2), amount2);
|
||
assertEq(vault.totalSupply(), amount1 + amount2);
|
||
assertEq(vault.totalAssets(), amount1 + amount2);
|
||
}
|
||
|
||
function test_11_CannotDepositZeroAmount() public {
|
||
vault = _createVault();
|
||
|
||
vm.startPrank(user1);
|
||
vm.expectRevert(YTAssetVault.InvalidAmount.selector);
|
||
vault.depositYT(0);
|
||
vm.stopPrank();
|
||
}
|
||
|
||
function test_12_DepositYTHardCapEnforcement() public {
|
||
vault = _createVault();
|
||
|
||
// 尝试存款超过硬顶
|
||
uint256 overCapAmount = HARD_CAP + 1000 * 1e18;
|
||
|
||
vm.startPrank(user1);
|
||
usdc.mint(user1, overCapAmount); // 铸造足够的USDC
|
||
usdc.approve(address(vault), overCapAmount);
|
||
|
||
vm.expectRevert(YTAssetVault.HardCapExceeded.selector);
|
||
vault.depositYT(overCapAmount);
|
||
vm.stopPrank();
|
||
}
|
||
|
||
function test_13_DepositYTExactlyAtHardCap() public {
|
||
vault = _createVault();
|
||
|
||
vm.startPrank(user1);
|
||
usdc.mint(user1, HARD_CAP);
|
||
usdc.approve(address(vault), HARD_CAP);
|
||
vault.depositYT(HARD_CAP);
|
||
vm.stopPrank();
|
||
|
||
assertEq(vault.totalSupply(), HARD_CAP);
|
||
assertEq(vault.balanceOf(user1), HARD_CAP);
|
||
}
|
||
|
||
function test_14_WithdrawYT() public {
|
||
vault = _createVault();
|
||
|
||
// 先存款
|
||
uint256 depositAmount = 1000 * 1e18;
|
||
vm.startPrank(user1);
|
||
usdc.approve(address(vault), depositAmount);
|
||
vault.depositYT(depositAmount);
|
||
vm.stopPrank();
|
||
|
||
// 快进到赎回时间之后
|
||
vm.warp(vault.nextRedemptionTime() + 1);
|
||
|
||
// 提交提现请求
|
||
uint256 withdrawAmount = 500 * 1e18; // 提取500 YT
|
||
uint256 expectedUsdc = 500 * 1e18; // 价格1:1，获得500 USDC
|
||
|
||
uint256 user1UsdcBefore = usdc.balanceOf(user1);
|
||
|
||
vm.startPrank(user1);
|
||
vm.expectEmit(true, true, false, true);
|
||
emit WithdrawRequestCreated(0, user1, withdrawAmount, expectedUsdc, 0);
|
||
|
||
uint256 requestId = vault.withdrawYT(withdrawAmount);
|
||
vm.stopPrank();
|
||
|
||
// 验证请求创建
|
||
assertEq(requestId, 0);
|
||
assertEq(vault.balanceOf(user1), depositAmount - withdrawAmount); // YT已销毁
|
||
assertEq(vault.totalSupply(), depositAmount - withdrawAmount);
|
||
assertEq(usdc.balanceOf(user1), user1UsdcBefore); // USDC还未发放
|
||
assertEq(vault.pendingRequestsCount(), 1);
|
||
|
||
// 批量处理提现请求
|
||
vm.prank(manager);
|
||
(uint256 processedCount, uint256 totalDistributed) = vault.processBatchWithdrawals(10);
|
||
|
||
// 验证结果
|
||
assertEq(processedCount, 1);
|
||
assertEq(totalDistributed, expectedUsdc);
|
||
assertEq(usdc.balanceOf(user1), user1UsdcBefore + expectedUsdc); // 现在收到了USDC
|
||
assertEq(vault.pendingRequestsCount(), 0);
|
||
}
|
||
|
||
function test_15_WithdrawYTWithDifferentPrices() public {
|
||
vault = _createVault();
|
||
|
||
// 存款
|
||
uint256 depositAmount = 1000 * 1e18;
|
||
vm.startPrank(user1);
|
||
usdc.approve(address(vault), depositAmount);
|
||
vault.depositYT(depositAmount);
|
||
vm.stopPrank();
|
||
|
||
// 更新YT价格为 1.05 (YT升值)，USDC价格更新为 0.98
|
||
factory.updateVaultPrices(
|
||
address(vault),
|
||
1050000000000000000000000000000 // 1.05
|
||
);
|
||
usdcPriceFeed.updatePrice(98000000); // $0.98 in Chainlink format
|
||
|
||
// 快进到赎回时间
|
||
vm.warp(vault.nextRedemptionTime() + 1);
|
||
|
||
// 提交提现请求
|
||
uint256 withdrawAmount = 500 * 1e18;
|
||
// usdcAmount = 500 YT * $1.05 / $0.98 = 535.714285714285714285 USDC
|
||
// 使用公式: usdcAmount = ytAmount * ytPrice / (usdcPrice * conversionFactor)
|
||
uint256 expectedUsdc = (withdrawAmount * 1050000000000000000000000000000) / (98000000 * 1e22);
|
||
|
||
uint256 user1BalanceBefore = usdc.balanceOf(user1);
|
||
|
||
vm.startPrank(user1);
|
||
uint256 requestId = vault.withdrawYT(withdrawAmount);
|
||
vm.stopPrank();
|
||
|
||
assertEq(requestId, 0);
|
||
|
||
// 批量处理
|
||
vm.prank(manager);
|
||
vault.processBatchWithdrawals(10);
|
||
|
||
// 验证用户收到的USDC（余额增加量）
|
||
assertEq(usdc.balanceOf(user1), user1BalanceBefore + expectedUsdc);
|
||
assertEq(expectedUsdc, 535714285714285714285); // 约535.71 USDC
|
||
}
|
||
|
||
function test_16_CannotWithdrawBeforeRedemptionTime() public {
|
||
vault = _createVault();
|
||
|
||
// 存款
|
||
vm.startPrank(user1);
|
||
usdc.approve(address(vault), 1000 * 1e18);
|
||
vault.depositYT(1000 * 1e18);
|
||
|
||
// 尝试在赎回时间前提款
|
||
vm.expectRevert(YTAssetVault.StillInLockPeriod.selector);
|
||
vault.withdrawYT(500 * 1e18);
|
||
vm.stopPrank();
|
||
}
|
||
|
||
function test_17_CannotWithdrawZeroAmount() public {
|
||
vault = _createVault();
|
||
|
||
vm.warp(vault.nextRedemptionTime() + 1);
|
||
|
||
vm.startPrank(user1);
|
||
vm.expectRevert(YTAssetVault.InvalidAmount.selector);
|
||
vault.withdrawYT(0);
|
||
vm.stopPrank();
|
||
}
|
||
|
||
function test_18_CannotWithdrawMoreThanBalance() public {
|
||
vault = _createVault();
|
||
|
||
vm.startPrank(user1);
|
||
usdc.approve(address(vault), 1000 * 1e18);
|
||
vault.depositYT(1000 * 1e18);
|
||
vm.stopPrank();
|
||
|
||
vm.warp(vault.nextRedemptionTime() + 1);
|
||
|
||
vm.startPrank(user1);
|
||
vm.expectRevert(YTAssetVault.InsufficientYTA.selector);
|
||
vault.withdrawYT(2000 * 1e18);
|
||
vm.stopPrank();
|
||
}
|
||
|
||
function test_19_ProcessStopsWhenInsufficientUSDC() public {
|
||
vault = _createVault();
|
||
|
||
// User1存款
|
||
vm.startPrank(user1);
|
||
usdc.approve(address(vault), 1000 * 1e18);
|
||
vault.depositYT(1000 * 1e18);
|
||
vm.stopPrank();
|
||
|
||
// Manager提取所有USDC
|
||
vm.prank(manager);
|
||
vault.withdrawForManagement(manager, 1000 * 1e18);
|
||
|
||
// 快进到赎回时间
|
||
vm.warp(vault.nextRedemptionTime() + 1);
|
||
|
||
// User1可以提交提现请求（即使vault中没有USDC）
|
||
vm.startPrank(user1);
|
||
uint256 requestId = vault.withdrawYT(500 * 1e18);
|
||
vm.stopPrank();
|
||
|
||
assertEq(requestId, 0);
|
||
assertEq(vault.pendingRequestsCount(), 1);
|
||
|
||
// 但是批量处理时会因为资金不足而处理0个请求
|
||
vm.prank(manager);
|
||
(uint256 processedCount, ) = vault.processBatchWithdrawals(10);
|
||
|
||
assertEq(processedCount, 0); // 没有处理任何请求
|
||
assertEq(vault.pendingRequestsCount(), 1); // 请求仍在队列中
|
||
|
||
// Manager归还资金后可以处理
|
||
vm.startPrank(manager);
|
||
usdc.approve(address(vault), 1000 * 1e18);
|
||
vault.depositManagedAssets(1000 * 1e18);
|
||
vm.stopPrank();
|
||
|
||
// 现在可以处理了
|
||
vm.prank(manager);
|
||
(uint256 processedCount2, ) = vault.processBatchWithdrawals(10);
|
||
|
||
assertEq(processedCount2, 1);
|
||
assertEq(vault.pendingRequestsCount(), 0);
|
||
}
|
||
|
||
function test_20_UpdatePrices() public {
|
||
vault = _createVault();
|
||
|
||
uint256 newYtPrice = 1020000000000000000000000000000; // 1.02
|
||
|
||
vm.expectEmit(false, false, false, true);
|
||
emit PriceUpdated(newYtPrice, block.timestamp);
|
||
|
||
factory.updateVaultPrices(address(vault), newYtPrice);
|
||
|
||
assertEq(vault.ytPrice(), newYtPrice);
|
||
}
|
||
|
||
function test_21_UpdatePricesOnlyFactory() public {
|
||
vault = _createVault();
|
||
|
||
// 测试非factory调用者（包括manager）无法直接调用
|
||
vm.prank(user1);
|
||
vm.expectRevert(YTAssetVault.Forbidden.selector);
|
||
vault.updatePrices(1020000000000000000000000000000);
|
||
|
||
// manager也不能直接调用
|
||
vm.prank(manager);
|
||
vm.expectRevert(YTAssetVault.Forbidden.selector);
|
||
vault.updatePrices(1020000000000000000000000000000);
|
||
}
|
||
|
||
function test_22_CannotUpdatePricesWithZero() public {
|
||
vault = _createVault();
|
||
|
||
vm.expectRevert(YTAssetVault.InvalidPrice.selector);
|
||
factory.updateVaultPrices(address(vault), 0);
|
||
}
|
||
|
||
function test_23_WithdrawForManagement() public {
|
||
vault = _createVault();
|
||
|
||
// 先存款
|
||
vm.startPrank(user1);
|
||
usdc.approve(address(vault), 10000 * 1e18);
|
||
vault.depositYT(10000 * 1e18);
|
||
vm.stopPrank();
|
||
|
||
// Manager提取用于投资
|
||
uint256 withdrawAmount = 5000 * 1e18;
|
||
uint256 managerBalanceBefore = usdc.balanceOf(manager);
|
||
|
||
vm.expectEmit(true, false, false, true);
|
||
emit AssetsWithdrawn(manager, withdrawAmount);
|
||
|
||
vm.prank(manager);
|
||
vault.withdrawForManagement(manager, withdrawAmount);
|
||
|
||
// 验证
|
||
assertEq(vault.managedAssets(), withdrawAmount);
|
||
assertEq(vault.idleAssets(), 5000 * 1e18);
|
||
assertEq(vault.totalAssets(), 10000 * 1e18); // totalAssets = idle + managed
|
||
assertEq(usdc.balanceOf(manager), managerBalanceBefore + withdrawAmount);
|
||
}
|
||
|
||
function test_24_DepositManagedAssetsFullReturn() public {
|
||
vault = _createVault();
|
||
|
||
// 存款
|
||
vm.startPrank(user1);
|
||
usdc.approve(address(vault), 10000 * 1e18);
|
||
vault.depositYT(10000 * 1e18);
|
||
vm.stopPrank();
|
||
|
||
// Manager提取
|
||
vm.prank(manager);
|
||
vault.withdrawForManagement(manager, 5000 * 1e18);
|
||
|
||
// Manager归还全部（无盈亏）
|
||
vm.startPrank(manager);
|
||
usdc.approve(address(vault), 5000 * 1e18);
|
||
|
||
vm.expectEmit(false, false, false, true);
|
||
emit AssetsDeposited(5000 * 1e18);
|
||
|
||
vault.depositManagedAssets(5000 * 1e18);
|
||
vm.stopPrank();
|
||
|
||
// 验证
|
||
assertEq(vault.managedAssets(), 0);
|
||
assertEq(vault.idleAssets(), 10000 * 1e18);
|
||
assertEq(vault.totalAssets(), 10000 * 1e18);
|
||
}
|
||
|
||
function test_25_DepositManagedAssetsWithProfit() public {
|
||
vault = _createVault();
|
||
|
||
// 存款
|
||
vm.startPrank(user1);
|
||
usdc.approve(address(vault), 10000 * 1e18);
|
||
vault.depositYT(10000 * 1e18);
|
||
vm.stopPrank();
|
||
|
||
// Manager提取
|
||
vm.prank(manager);
|
||
vault.withdrawForManagement(manager, 5000 * 1e18);
|
||
|
||
// Manager归还本金+利润
|
||
uint256 returnAmount = 6000 * 1e18; // 赚了1000 USDC
|
||
vm.startPrank(manager);
|
||
usdc.approve(address(vault), returnAmount);
|
||
vault.depositManagedAssets(returnAmount);
|
||
vm.stopPrank();
|
||
|
||
// 验证
|
||
assertEq(vault.managedAssets(), 0);
|
||
assertEq(vault.idleAssets(), 11000 * 1e18); // 5000 + 6000
|
||
assertEq(vault.totalAssets(), 11000 * 1e18); // 增加了1000的利润
|
||
}
|
||
|
||
function test_26_SetHardCap() public {
|
||
vault = _createVault();
|
||
|
||
uint256 newHardCap = 2000000 * 1e18;
|
||
|
||
vm.expectEmit(false, false, false, true);
|
||
emit HardCapSet(newHardCap);
|
||
|
||
factory.setHardCap(address(vault), newHardCap);
|
||
|
||
assertEq(vault.hardCap(), newHardCap);
|
||
}
|
||
|
||
function test_27_CannotSetHardCapBelowTotalSupply() public {
|
||
vault = _createVault();
|
||
|
||
// 先存款
|
||
vm.startPrank(user1);
|
||
usdc.approve(address(vault), 100000 * 1e18);
|
||
vault.depositYT(100000 * 1e18);
|
||
vm.stopPrank();
|
||
|
||
// 尝试设置低于当前总供应量的硬顶
|
||
vm.expectRevert(YTAssetVault.InvalidHardCap.selector);
|
||
factory.setHardCap(address(vault), 50000 * 1e18);
|
||
}
|
||
|
||
function test_28_SetNextRedemptionTime() public {
|
||
vault = _createVault();
|
||
|
||
uint256 newRedemptionTime = block.timestamp + 90 days;
|
||
|
||
vm.expectEmit(false, false, false, true);
|
||
emit NextRedemptionTimeSet(newRedemptionTime);
|
||
|
||
factory.setVaultNextRedemptionTime(address(vault), newRedemptionTime);
|
||
|
||
assertEq(vault.nextRedemptionTime(), newRedemptionTime);
|
||
}
|
||
|
||
function test_29_PauseByFactory() public {
|
||
vault = _createVault();
|
||
|
||
// Factory可以暂停
|
||
factory.pauseVault(address(vault));
|
||
assertTrue(vault.paused());
|
||
|
||
// Factory可以恢复
|
||
factory.unpauseVault(address(vault));
|
||
assertFalse(vault.paused());
|
||
}
|
||
|
||
function test_30_OnlyFactoryCanPause() public {
|
||
vault = _createVault();
|
||
|
||
// User不能暂停
|
||
vm.startPrank(user1);
|
||
vm.expectRevert(YTAssetVault.Forbidden.selector);
|
||
vault.pause();
|
||
vm.stopPrank();
|
||
|
||
// Manager也不能暂停
|
||
vm.startPrank(manager);
|
||
vm.expectRevert(YTAssetVault.Forbidden.selector);
|
||
vault.pause();
|
||
vm.stopPrank();
|
||
}
|
||
|
||
function test_31_CannotDepositWhenPaused() public {
|
||
vault = _createVault();
|
||
|
||
// 暂停vault
|
||
factory.pauseVault(address(vault));
|
||
|
||
// 尝试存款应该失败
|
||
vm.startPrank(user1);
|
||
usdc.approve(address(vault), 1000 * 1e18);
|
||
|
||
vm.expectRevert(abi.encodeWithSignature("EnforcedPause()"));
|
||
vault.depositYT(1000 * 1e18);
|
||
vm.stopPrank();
|
||
|
||
// 恢复后应该可以存款
|
||
factory.unpauseVault(address(vault));
|
||
|
||
vm.startPrank(user1);
|
||
uint256 ytReceived = vault.depositYT(1000 * 1e18);
|
||
vm.stopPrank();
|
||
|
||
assertEq(ytReceived, 1000 * 1e18);
|
||
}
|
||
|
||
function test_32_GetVaultInfo() public {
|
||
vault = _createVault();
|
||
|
||
// 存款
|
||
vm.startPrank(user1);
|
||
usdc.approve(address(vault), 10000 * 1e18);
|
||
vault.depositYT(10000 * 1e18);
|
||
vm.stopPrank();
|
||
|
||
// Manager提取部分资金
|
||
vm.prank(manager);
|
||
vault.withdrawForManagement(manager, 3000 * 1e18);
|
||
|
||
(
|
||
uint256 totalAssets,
|
||
uint256 idleAssets,
|
||
uint256 managedAssets_,
|
||
uint256 totalSupply_,
|
||
uint256 hardCap_,
|
||
uint256 usdcPrice,
|
||
uint256 ytPrice_,
|
||
uint256 nextRedemptionTime_
|
||
) = vault.getVaultInfo();
|
||
|
||
assertEq(totalAssets, 10000 * 1e18);
|
||
assertEq(idleAssets, 7000 * 1e18);
|
||
assertEq(managedAssets_, 3000 * 1e18);
|
||
assertEq(totalSupply_, 10000 * 1e18);
|
||
assertEq(hardCap_, HARD_CAP);
|
||
assertEq(usdcPrice, INITIAL_USDC_PRICE);
|
||
assertEq(ytPrice_, INITIAL_YT_PRICE);
|
||
assertEq(nextRedemptionTime_, vault.nextRedemptionTime());
|
||
}
|
||
|
||
function test_33_PreviewFunctions() public {
|
||
vault = _createVault();
|
||
|
||
// 更新价格
|
||
factory.updateVaultPrices(
|
||
address(vault),
|
||
1020000000000000000000000000000 // YT = 1.02
|
||
);
|
||
|
||
// 预览买入
|
||
uint256 usdcAmount = 1000 * 1e18;
|
||
uint256 expectedYt = (usdcAmount * INITIAL_USDC_PRICE * 1e22) / 1020000000000000000000000000000;
|
||
uint256 previewBuyAmount = vault.previewBuy(usdcAmount);
|
||
assertEq(previewBuyAmount, expectedYt);
|
||
assertEq(previewBuyAmount, 980392156862745098039);
|
||
|
||
// 预览卖出
|
||
uint256 ytAmount = 1000 * 1e18;
|
||
uint256 expectedUsdc = (ytAmount * 1020000000000000000000000000000) / (INITIAL_USDC_PRICE * 1e22);
|
||
uint256 previewSellAmount = vault.previewSell(ytAmount);
|
||
assertEq(previewSellAmount, expectedUsdc);
|
||
assertEq(previewSellAmount, 1020000000000000000000);
|
||
}
|
||
|
||
function test_34_CanRedeemNow() public {
|
||
vault = _createVault();
|
||
|
||
// 赎回时间前
|
||
assertFalse(vault.canRedeemNow());
|
||
|
||
// 赎回时间后
|
||
vm.warp(vault.nextRedemptionTime() + 1);
|
||
assertTrue(vault.canRedeemNow());
|
||
}
|
||
|
||
function test_35_GetTimeUntilNextRedemption() public {
|
||
vault = _createVault();
|
||
|
||
uint256 redemptionTime = vault.nextRedemptionTime();
|
||
uint256 currentTime = block.timestamp;
|
||
|
||
assertEq(vault.getTimeUntilNextRedemption(), redemptionTime - currentTime);
|
||
|
||
// 快进到赎回时间后
|
||
vm.warp(redemptionTime + 1);
|
||
assertEq(vault.getTimeUntilNextRedemption(), 0);
|
||
}
|
||
|
||
function test_36_CompleteLifecycle() public {
|
||
vault = _createVault();
|
||
|
||
// 1. 初始状态验证
|
||
assertEq(vault.totalSupply(), 0);
|
||
assertEq(vault.totalAssets(), 0);
|
||
|
||
// 2. User1和User2存款
|
||
vm.startPrank(user1);
|
||
usdc.approve(address(vault), 10000 * 1e18);
|
||
vault.depositYT(10000 * 1e18);
|
||
vm.stopPrank();
|
||
|
||
vm.startPrank(user2);
|
||
usdc.approve(address(vault), 5000 * 1e18);
|
||
vault.depositYT(5000 * 1e18);
|
||
vm.stopPrank();
|
||
|
||
assertEq(vault.totalSupply(), 15000 * 1e18);
|
||
assertEq(vault.totalAssets(), 15000 * 1e18);
|
||
|
||
// 3. Manager提取资金进行投资
|
||
vm.prank(manager);
|
||
vault.withdrawForManagement(manager, 8000 * 1e18);
|
||
|
||
assertEq(vault.managedAssets(), 8000 * 1e18);
|
||
assertEq(vault.idleAssets(), 7000 * 1e18);
|
||
assertEq(vault.totalAssets(), 15000 * 1e18);
|
||
|
||
// 4. 价格更新（YT涨到1.10）
|
||
factory.updateVaultPrices(
|
||
address(vault),
|
||
1100000000000000000000000000000 // YT涨到1.10
|
||
);
|
||
|
||
// 5. Manager归还资金+利润
|
||
vm.startPrank(manager);
|
||
usdc.approve(address(vault), 10000 * 1e18);
|
||
vault.depositManagedAssets(10000 * 1e18); // 归还本金+2000利润
|
||
vm.stopPrank();
|
||
|
||
assertEq(vault.managedAssets(), 0);
|
||
assertEq(vault.idleAssets(), 17000 * 1e18); // 增加了2000利润
|
||
assertEq(vault.totalAssets(), 17000 * 1e18);
|
||
|
||
// 6. 快进到赎回时间
|
||
vm.warp(vault.nextRedemptionTime() + 1);
|
||
|
||
// 7. User1提交提现请求
|
||
uint256 user1YtBalance = vault.balanceOf(user1);
|
||
uint256 withdrawYtAmount = 5000 * 1e18;
|
||
uint256 user1UsdcBefore = usdc.balanceOf(user1);
|
||
|
||
vm.startPrank(user1);
|
||
uint256 requestId = vault.withdrawYT(withdrawYtAmount);
|
||
vm.stopPrank();
|
||
|
||
assertEq(requestId, 0);
|
||
|
||
// 8. 批量处理提现
|
||
vm.prank(manager);
|
||
vault.processBatchWithdrawals(10);
|
||
|
||
// 按新价格计算: 5000 YT * $1.10 / $1.00 = 5500 USDC
|
||
uint256 expectedUsdc = (withdrawYtAmount * 1100000000000000000000000000000) / (INITIAL_USDC_PRICE * 1e22);
|
||
assertEq(usdc.balanceOf(user1), user1UsdcBefore + expectedUsdc);
|
||
assertEq(expectedUsdc, 5500000000000000000000);
|
||
|
||
// 验证最终状态
|
||
assertEq(vault.balanceOf(user1), user1YtBalance - withdrawYtAmount);
|
||
assertEq(vault.totalSupply(), 10000 * 1e18);
|
||
}
|
||
|
||
function test_37_ChainlinkPriceIntegration() public {
|
||
vault = _createVault();
|
||
|
||
// 测试不同的USDC价格
|
||
usdcPriceFeed.updatePrice(105000000); // $1.05
|
||
|
||
uint256 depositAmount = 1000 * 1e18;
|
||
// ytAmount = 1000 * 1.05 / 1.00 = 1050 YT
|
||
uint256 expectedYt = (depositAmount * 105000000 * 1e22) / INITIAL_YT_PRICE;
|
||
|
||
vm.startPrank(user1);
|
||
usdc.approve(address(vault), depositAmount);
|
||
uint256 ytReceived = vault.depositYT(depositAmount);
|
||
vm.stopPrank();
|
||
|
||
assertEq(ytReceived, expectedYt);
|
||
assertEq(ytReceived, 1050 * 1e18);
|
||
}
|
||
|
||
function test_38_ChainlinkNegativePriceReverts() public {
|
||
vault = _createVault();
|
||
|
||
// 设置负价格
|
||
usdcPriceFeed.updatePrice(-1);
|
||
|
||
vm.startPrank(user1);
|
||
usdc.approve(address(vault), 1000 * 1e18);
|
||
|
||
// 应该revert
|
||
vm.expectRevert(YTAssetVault.InvalidChainlinkPrice.selector);
|
||
vault.depositYT(1000 * 1e18);
|
||
vm.stopPrank();
|
||
}
|
||
|
||
function test_39_ChainlinkZeroPriceReverts() public {
|
||
vault = _createVault();
|
||
|
||
// 设置零价格
|
||
usdcPriceFeed.updatePrice(0);
|
||
|
||
vm.startPrank(user1);
|
||
usdc.approve(address(vault), 1000 * 1e18);
|
||
|
||
// 应该revert
|
||
vm.expectRevert(YTAssetVault.InvalidChainlinkPrice.selector);
|
||
vault.depositYT(1000 * 1e18);
|
||
vm.stopPrank();
|
||
}
|
||
|
||
function test_40_BatchProcessWithMultipleRequests() public {
|
||
vault = _createVault();
|
||
|
||
// 准备5个用户和请求
|
||
address[] memory users = new address[](5);
|
||
for (uint i = 0; i < 5; i++) {
|
||
users[i] = makeAddr(string(abi.encodePacked("user", i)));
|
||
usdc.transfer(users[i], 1000 * 1e18);
|
||
|
||
vm.startPrank(users[i]);
|
||
usdc.approve(address(vault), 1000 * 1e18);
|
||
vault.depositYT(1000 * 1e18);
|
||
vm.stopPrank();
|
||
}
|
||
|
||
// 快进到赎回时间
|
||
vm.warp(vault.nextRedemptionTime() + 1);
|
||
|
||
// 提交5个提现请求
|
||
for (uint i = 0; i < 5; i++) {
|
||
vm.prank(users[i]);
|
||
vault.withdrawYT(500 * 1e18);
|
||
}
|
||
|
||
assertEq(vault.pendingRequestsCount(), 5);
|
||
|
||
// 第一次批量处理：只处理2个
|
||
vm.prank(manager);
|
||
(uint256 processedCount1, ) = vault.processBatchWithdrawals(2);
|
||
|
||
assertEq(processedCount1, 2);
|
||
assertEq(vault.pendingRequestsCount(), 3);
|
||
|
||
// 第二次批量处理：处理剩余3个
|
||
vm.prank(manager);
|
||
(uint256 processedCount2, ) = vault.processBatchWithdrawals(10);
|
||
|
||
assertEq(processedCount2, 3);
|
||
assertEq(vault.pendingRequestsCount(), 0);
|
||
}
|
||
}
|