前言
本文基于 OpenZeppelin v5 + Solidity 0.8.20+，用 200 行代码带你从零搭建「可编译、可部署、可扩容」的收益聚合器 MVP。流程只有四步：
- 双 ERC20：一份生息资产，一份收益凭证；
- Chainlink 喂价：链上美元计价，一秒搞定；
- 份额制资金池：按份额自动分收益，无需记账；
- Hardhat 全套：防重入、Owner 救援、单元测试、部署脚本，一键
compile / test / deploy打通闭环。
智能合约
-
代币合约
// SPDX-License-Identifier: MIT
// Compatible with OpenZeppelin Contracts ^5.0.0
pragma solidity ^0.8.22;
import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import {ERC20Burnable} from "@openzeppelin/contracts/token/ERC20/extensions/ERC20Burnable.sol";
import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
import "hardhat/console.sol";
contract MyToken1 is ERC20, ERC20Burnable, Ownable {
constructor(string memory name_,string memory symbol_,address initialOwner)
ERC20(name_, symbol_)
Ownable(initialOwner)
{
_mint(msg.sender, 1000 * 10 ** decimals());
}
function mint(address to, uint256 amount) public onlyOwner {
_mint(to, amount);
}
}
-
喂价合约
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;
import { AggregatorV3Interface } from "@chainlink/contracts/src/v0.8/shared/interfaces/AggregatorV3Interface.sol";
contract MockV3Aggregator is AggregatorV3Interface {
uint256 public constant versionvar = 4;
uint8 public decimalsvar;
int256 public latestAnswer;
uint256 public latestTimestamp;
uint256 public latestRound;
mapping(uint256 => int256) public getAnswer;
mapping(uint256 => uint256) public getTimestamp;
mapping(uint256 => uint256) private getStartedAt;
string private descriptionvar;
constructor(
uint8 _decimals,
string memory _description,
int256 _initialAnswer
) {
decimalsvar = _decimals;
descriptionvar = _description;
updateAnswer(_initialAnswer);
}
function updateAnswer(int256 _answer) public {
latestAnswer = _answer;
latestTimestamp = block.timestamp;
latestRound++;
getAnswer[latestRound] = _answer;
getTimestamp[latestRound] = block.timestamp;
getStartedAt[latestRound] = block.timestamp;
}
function getRoundData(uint80 _roundId)
external
view
override
returns (
uint80 roundId,
int256 answer,
uint256 startedAt,
uint256 updatedAt,
uint80 answeredInRound
)
{
return (
_roundId,
getAnswer[_roundId],
getStartedAt[_roundId],
getTimestamp[_roundId],
_roundId
);
}
function latestRoundData()
external
view
override
returns (
uint80 roundId,
int256 answer,
uint256 startedAt,
uint256 updatedAt,
uint80 answeredInRound
)
{
return (
uint80(latestRound),
latestAnswer,
getStartedAt[latestRound],
latestTimestamp,
uint80(latestRound)
);
}
function decimals() external view override returns (uint8) {
return decimalsvar;
}
function description() external view override returns (string memory) {
return descriptionvar;
}
function version() external pure override returns (uint256) {
return versionvar;
}
}
-
聚合器合约(核心)
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/utils/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@chainlink/contracts/src/v0.8/shared/interfaces/AggregatorV3Interface.sol";
contract YieldAggregator is ReentrancyGuard, Ownable {
using SafeERC20 for IERC20;
IERC20 public immutable asset; // 存入的资产，如 USDC
IERC20 public immutable rewardToken; // 收益代币，如 yUSDC
AggregatorV3Interface public priceFeed; // Chainlink 价格预言机
mapping(address => uint256) public shares; // 用户份额
uint256 public totalShares;
uint256 public totalAssetsDeposited;
event Deposit(address indexed user, uint256 amount, uint256 shares);
event Withdraw(address indexed user, uint256 amount, uint256 shares);
constructor(
address _asset,
address _rewardToken,
address _priceFeed
) Ownable(msg.sender) {
asset = IERC20(_asset);
rewardToken = IERC20(_rewardToken);
priceFeed = AggregatorV3Interface(_priceFeed);
}
// 获取 ETH/USD 价格（示例）
function getETHPrice() public view returns (uint256) {
(, int price, , , ) = priceFeed.latestRoundData();
require(price > 0, "Invalid price");
return uint256(price);
}
// 存入资产
function deposit(uint256 amount) external nonReentrant {
require(amount > 0, "Amount must be > 0");
uint256 sharesToMint = totalShares == 0 ? amount : (amount * totalShares) / totalAssetsDeposited;
asset.safeTransferFrom(msg.sender, address(this), amount);
shares[msg.sender] += sharesToMint;
totalShares += sharesToMint;
totalAssetsDeposited += amount;
// 模拟策略投资（此处省略实际策略调用）
// 例如：strategy.deposit(amount);
emit Deposit(msg.sender, amount, sharesToMint);
}
// 提取资产 + 收益
function withdraw(uint256 sharesAmount) external nonReentrant {
require(shares[msg.sender] >= sharesAmount, "Not enough shares");
uint256 assetAmount = (sharesAmount * totalAssetsDeposited) / totalShares;
shares[msg.sender] -= sharesAmount;
totalShares -= sharesAmount;
totalAssetsDeposited -= assetAmount;
// 模拟策略赎回
// 例如：strategy.withdraw(assetAmount);
asset.safeTransfer(msg.sender, assetAmount);
emit Withdraw(msg.sender, assetAmount, sharesAmount);
}
// 查询用户资产价值（USD）
function getUserAssetValue(address user) external view returns (uint256) {
uint256 userAssets = (shares[user] * totalAssetsDeposited) / totalShares;
return userAssets; // 若资产为 USDC，可视为 1:1 USD
}
// 管理员救援函数
function rescue(address token, uint256 amount) external onlyOwner {
IERC20(token).safeTransfer(msg.sender, amount);
}
}
编译指令：npx hardhat compile
测试
const { expect } = require("chai");
const { ethers, deployments } = require("hardhat");
describe("YieldAggregator", function () {
let yieldAg; // 被测合约
let asset; // 存入资产（MyToken3）
let reward; // 奖励代币（MyToken1 / USDC）
let feed; // MockV3Aggregator
let owner, alice, bob;
const INITIAL_PRICE = 2000_0000_0000; // 8 位小数，2000 USD/ETH
const DEPOSIT_AMOUNT = ethers.parseUnits("100", 18); // 100 个 asset 代币
beforeEach(async () => {
[owner, alice, bob] = await ethers.getSigners();
// 必须保证 deployments 文件夹里有对应的脚本：
// 01-deploy-tokens.js 02-deploy-mock.js 03-deploy-yield.js
await deployments.fixture(["token3", "token1", "MockV3Aggregator", "YieldAggregator"]);
const a = await deployments.get("MyToken1"); // 存入资产
const b = await deployments.get("MyToken3"); // 奖励代币（USDC）
const c = await deployments.get("MockV3Aggregator");
const d = await deployments.get("YieldAggregator");
asset = await ethers.getContractAt("MyToken1", a.address);
reward = await ethers.getContractAt("MyToken3", b.address);
feed = await ethers.getContractAt("MockV3Aggregator", c.address);
yieldAg = await ethers.getContractAt("YieldAggregator", d.address);
});
/* ------------------ helper ------------------ */
async function mintAndApprove(user, amount) {
await asset.mint(user.address, amount);
await asset.connect(user).approve(yieldAg.target, amount);
}
/* ------------------ 测试用例 ------------------ */
it("部署后初始状态正确", async () => {
console.log(await yieldAg.asset())
console.log(asset.target);
console.log(await yieldAg.rewardToken())
console.log(reward.target);
console.log(await yieldAg.priceFeed())
console.log(feed.target);
console.log(await yieldAg.totalShares());
console.log(await yieldAg.totalAssetsDeposited());
});
it("首次存入正确铸造份额", async () => {
await mintAndApprove(alice, DEPOSIT_AMOUNT);
await yieldAg.connect(alice).deposit(DEPOSIT_AMOUNT)
// .to.emit(yieldAg, "Deposit")
// .withArgs(alice.address, DEPOSIT_AMOUNT, DEPOSIT_AMOUNT); // 1:1
console.log("首次存入后用户份额:",await yieldAg.shares(alice.address))
// .to.eq(DEPOSIT_AMOUNT);
console.log("首次存入后份额总量:",await yieldAg.totalShares())
// .to.eq(DEPOSIT_AMOUNT);
console.log("首次存入后资产总量:",await yieldAg.totalAssetsDeposited())
// .to.eq(DEPOSIT_AMOUNT);
});
it("二次存入按比例铸造份额", async () => {
await mintAndApprove(alice, DEPOSIT_AMOUNT);
await mintAndApprove(bob, DEPOSIT_AMOUNT);
await yieldAg.connect(alice).deposit(DEPOSIT_AMOUNT); // 总量 100，份额 100
await yieldAg.connect(bob).deposit(DEPOSIT_AMOUNT); // 总量 200，应得 100 份额
expect(await yieldAg.shares(bob.address)).to.eq(DEPOSIT_AMOUNT);
expect(await yieldAg.totalShares()).to.eq(DEPOSIT_AMOUNT * 2n);
});
it("提取后份额与资产减少", async () => {
await mintAndApprove(alice, DEPOSIT_AMOUNT);
await yieldAg.connect(alice).deposit(DEPOSIT_AMOUNT);
const withdrawShares = DEPOSIT_AMOUNT / 2n;
const expectAssets = DEPOSIT_AMOUNT / 2n;
await expect(yieldAg.connect(alice).withdraw(withdrawShares))
.to.emit(yieldAg, "Withdraw")
.withArgs(alice.address, expectAssets, withdrawShares);
expect(await yieldAg.shares(alice.address)).to.eq(withdrawShares);
expect(await yieldAg.totalShares()).to.eq(withdrawShares);
expect(await yieldAg.totalAssetsDeposited()).to.eq(withdrawShares);
});
it("无法提取超过自身份额", async () => {
await mintAndApprove(alice, DEPOSIT_AMOUNT);
await yieldAg.connect(alice).deposit(DEPOSIT_AMOUNT);
await expect(
yieldAg.connect(alice).withdraw(DEPOSIT_AMOUNT + 1n)
).to.be.revertedWith("Not enough shares");
});
it("rescue 只能 owner 调用", async () => {
const rescueAmount = ethers.parseUnits("10", 18);
await asset.mint(yieldAg.target, rescueAmount);
// owner 可以 rescue
await expect(() =>
yieldAg.connect(owner).rescue(asset.target, rescueAmount)
).to.changeTokenBalance(asset, owner, rescueAmount);
// alice 不能 rescue
await expect(
yieldAg.connect(alice).rescue(asset.target, 1n)
).to.be.reverted;
});
it("getETHPrice 返回 Mock 价格", async () => {
expect(await yieldAg.getETHPrice()).to.eq(INITIAL_PRICE);
});
it("getUserAssetValue 计算正确", async () => {
await mintAndApprove(alice, DEPOSIT_AMOUNT);
await yieldAg.connect(alice).deposit(DEPOSIT_AMOUNT);
// 1:1 对应，USDC 视为 1 USD
expect(await yieldAg.getUserAssetValue(alice.address)).to.eq(DEPOSIT_AMOUNT);
});
});
测试指令：npx hardhat test ./test/xxx.js
部署
module.exports = async ({getNamedAccounts,deployments})=>{
const getNamedAccount = (await getNamedAccounts()).firstAccount;
const secondAccount= (await getNamedAccounts()).secondAccount;
console.log('secondAccount',secondAccount)
const {deploy,log} = deployments;
//资产
const MyAsset=await deploy("MyToken1",{
from:getNamedAccount,
args: ["MyAsset","MyAsset",getNamedAccount],//参数
log: true,
});
console.log('MyToken 资产合约地址',MyAsset.address)
//奖励代币
const MyAward = await deploy("MyToken3",{
from:getNamedAccount,
args: ["MyAward","MA",getNamedAccount],//参数
log: true,
})
console.log('MyAward 奖励代币合约地址',MyAward.address)
//执行MockV3Aggregator部署合约
const MockV3Aggregator=await deploy("MockV3Aggregator",{
from:getNamedAccount,
args: [8,"USDC/USD", 200000000000],//参数
log: true,
})
console.log("MockV3Aggregator合约地址:", MockV3Aggregator.address);
const YieldAggregator=await deploy("YieldAggregator",{
from:getNamedAccount,
args: [MyAsset.address,MyAward.address,MockV3Aggregator.address],//参数 资产地址,奖励地址,喂价
log: true,
})
// await hre.run("verify:verify", {
// address: TokenC.address,
// constructorArguments: [TokenName, TokenSymbol],
// });
console.log('YieldAggregator 聚合器合约地址',YieldAggregator.address)
}
module.exports.tags = ["all", "YieldAggregator"];
部署指令：npx hardhat deploy --tags YieldAggregator
总结
本文用三份合约 + 一套测试/部署脚本，交付了一台「袖珍版 Y 机」：
- MyToken1：可增发、可燃烧的生息资产，也是用户最终取回的「本金+收益」；
- MockV3Aggregator：本地模拟 Chainlink，8 位小数 USDC/USD 喂价，方便离线调试；
- YieldAggregator：核心资金池，采用「份额制」记账，任何时刻按份额比例享有底层资产， deposit/withdraw 均防重入，并预留策略插槽，可无缝接入外部 DeFi 挖矿。
测试用例覆盖首次/二次存入、部分/超额提取、Owner 救援、价格获取、用户资产估值等 8 条核心路径，全部绿灯。部署脚本一键完成代币、喂价、聚合器的链上生成，并打印地址，方便前端直接对接。
后续可以进行如下优化迭代：
- 把 Mock 换成主网 Oracle，接入真实 USDC；
- 在 deposit/withdraw 里调用 Aave/Compound/Yearn 策略，让资金真的去挖矿；
- 叠加 Keeper 自动复利、多策略路由、Vault Token 可交易化，逐步进化成商业级收益聚合器。
代码已开源，fork 即可开干——愿你的 ETH 24 小时不打烊，收益永远在线！
