编译器
0.8.16+commit.07a7930e
文件 1 的 18：Address.sol
pragma solidity ^0.8.1;
library Address {
function isContract(address account) internal view returns (bool) {
return account.code.length > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success, ) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, "Address: low-level call failed");
}
function functionCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(
address target,
bytes memory data,
uint256 value
) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(
address target,
bytes memory data,
uint256 value,
string memory errorMessage
) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(
address target,
bytes memory data,
string memory errorMessage
) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function verifyCallResult(
bool success,
bytes memory returndata,
string memory errorMessage
) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
if (returndata.length > 0) {
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}文件 2 的 18：Context.sol
pragma solidity ^0.8.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}文件 3 的 18：DullahanRewardsStaking.sol
pragma solidity 0.8.16;
import "./interfaces/IScalingERC20.sol";
import "./oz/interfaces/IERC20.sol";
import "./oz/interfaces/IERC20.sol";
import "./oz/libraries/SafeERC20.sol";
import "./oz/utils/ReentrancyGuard.sol";
import "./oz/utils/Pausable.sol";
import "./utils/Owner.sol";
import {Errors} from "./utils/Errors.sol";
import {WadRayMath} from "./utils/WadRayMath.sol";
contract DullahanRewardsStaking is ReentrancyGuard, Pausable, Owner {
using SafeERC20 for IERC20;
using WadRayMath for uint256;
uint256 private constant UNIT = 1e18;
uint256 private constant MAX_BPS = 10000;
uint256 private constant MAX_UINT256 = 2**256 - 1;
uint256 private constant DISTRIBUTION_DURATION = 604800;
uint256 private constant INITIAL_INDEX = 1e27;
uint256 private constant UPDATE_REWARD_RATIO = 8500;
uint256 private constant SEED_DEPOSIT = 0.001 ether;
struct UserRewardState {
uint256 lastRewardPerToken;
uint256 accruedRewards;
}
struct RewardState {
uint256 rewardPerToken;
uint128 lastUpdate;
uint128 distributionEndTimestamp;
uint256 ratePerSecond;
uint256 currentRewardAmount;
uint256 queuedRewardAmount;
mapping(address => UserRewardState) userStates;
}
struct UserClaimableRewards {
address reward;
uint256 claimableAmount;
}
struct UserClaimedRewards {
address reward;
uint256 amount;
}
bool public initialized;
address public immutable vault;
uint256 public totalScaledAmount;
mapping(address => uint256) public userScaledBalances;
address[] public rewardList;
mapping(address => RewardState) public rewardStates;
mapping(address => bool) public rewardDepositors;
mapping(address => address) public allowedClaimer;
event Initialized();
event Staked(address indexed caller, address indexed receiver, uint256 amount, uint256 scaledAmount);
event Unstaked(address indexed owner, address indexed receiver, uint256 amount, uint256 scaledAmount);
event ClaimedRewards(address indexed reward, address indexed user, address indexed receiver, uint256 amount);
event SetUserAllowedClaimer(address indexed user, address indexed claimer);
event NewRewards(address indexed rewardToken, uint256 amount, uint256 endTimestamp);
event AddedRewardDepositor(address indexed depositor);
event RemovedRewardDepositor(address indexed depositor);
modifier onlyRewardDepositors() {
if(!rewardDepositors[msg.sender]) revert Errors.CallerNotAllowed();
_;
}
modifier isInitialized() {
if (!initialized) revert Errors.NotInitialized();
_;
}
constructor(
address _vault
) {
if(_vault == address(0)) revert Errors.AddressZero();
vault = _vault;
}
function init() external onlyOwner {
if(initialized) revert Errors.AlreadyInitialized();
initialized = true;
_stake(msg.sender, SEED_DEPOSIT, msg.sender);
emit Initialized();
}
function lastRewardUpdateTimestamp(address reward) public view returns(uint256) {
uint256 rewardEndTimestamp = rewardStates[reward].distributionEndTimestamp;
return block.timestamp > rewardEndTimestamp ? rewardEndTimestamp : block.timestamp;
}
function totalAssets() public view returns(uint256) {
return IScalingERC20(vault).balanceOf(address(this));
}
function getCurrentIndex() external view returns(uint256) {
return _getCurrentIndex();
}
function getRewardList() public view returns(address[] memory) {
return rewardList;
}
function userCurrentStakedAmount(address user) public view returns(uint256) {
return userScaledBalances[user].rayMul(_getCurrentIndex());
}
function getUserRewardState(address reward, address user) external view returns(UserRewardState memory) {
return rewardStates[reward].userStates[user];
}
function getUserAccruedRewards(address reward, address user) external view returns(uint256) {
return rewardStates[reward].userStates[user].accruedRewards + _getUserEarnedRewards(reward, user, _getNewRewardPerToken(reward));
}
function getUserTotalClaimableRewards(address user) external view returns(UserClaimableRewards[] memory){
address[] memory rewards = rewardList;
uint256 rewardsLength = rewards.length;
UserClaimableRewards[] memory rewardAmounts = new UserClaimableRewards[](rewardsLength);
for(uint256 i; i < rewardsLength;){
rewardAmounts[i].reward = rewards[i];
rewardAmounts[i].claimableAmount = rewardStates[rewards[i]].userStates[user].accruedRewards + _getUserEarnedRewards(rewards[i], user, _getNewRewardPerToken(rewards[i]));
unchecked { ++i; }
}
return rewardAmounts;
}
function stake(uint256 amount, address receiver) external nonReentrant isInitialized whenNotPaused returns(uint256) {
if(amount == 0) revert Errors.NullAmount();
if(receiver == address(0)) revert Errors.AddressZero();
return _stake(msg.sender, amount, receiver);
}
function _stake(address caller, uint256 amount, address receiver) internal returns(uint256) {
_updateAllUserRewardStates(receiver);
if(amount == MAX_UINT256) amount = IERC20(vault).balanceOf(caller);
uint256 scaledAmount = amount.rayDiv(_getCurrentIndex());
if(scaledAmount == 0) revert Errors.NullScaledAmount();
IERC20(vault).safeTransferFrom(caller, address(this), amount);
userScaledBalances[receiver] += scaledAmount;
totalScaledAmount += scaledAmount;
emit Staked(caller, receiver, amount, scaledAmount);
return scaledAmount;
}
function unstake(uint256 scaledAmount, address receiver) external nonReentrant isInitialized returns(uint256) {
if(scaledAmount == 0) revert Errors.NullScaledAmount();
if(receiver == address(0)) revert Errors.AddressZero();
_updateAllUserRewardStates(msg.sender);
if(scaledAmount == MAX_UINT256) scaledAmount = userScaledBalances[msg.sender];
uint256 amount = scaledAmount.rayMul(_getCurrentIndex());
if(amount == 0) revert Errors.NullAmount();
userScaledBalances[msg.sender] -= scaledAmount;
totalScaledAmount -= scaledAmount;
IERC20(vault).safeTransfer(receiver, amount);
emit Unstaked(msg.sender, receiver, amount, scaledAmount);
return amount;
}
function claimRewards(address reward, address receiver) external nonReentrant isInitialized whenNotPaused returns(uint256) {
if(receiver == address(0)) revert Errors.AddressZero();
return _claimRewards(reward, msg.sender, receiver);
}
function claimRewardsForUser(address reward, address user, address receiver) external nonReentrant isInitialized whenNotPaused returns(uint256) {
if(receiver == address(0) || user == address(0)) revert Errors.AddressZero();
if(msg.sender != allowedClaimer[user]) revert Errors.ClaimNotAllowed();
return _claimRewards(reward, user, receiver);
}
function claimAllRewards(address receiver) external nonReentrant isInitialized whenNotPaused returns(UserClaimedRewards[] memory) {
if(receiver == address(0)) revert Errors.AddressZero();
return _claimAllRewards(msg.sender, receiver);
}
function claimAllRewardsForUser(address user, address receiver) external nonReentrant isInitialized whenNotPaused returns(UserClaimedRewards[] memory) {
if(receiver == address(0) || user == address(0)) revert Errors.AddressZero();
if(msg.sender != allowedClaimer[user]) revert Errors.ClaimNotAllowed();
return _claimAllRewards(user, receiver);
}
function updateRewardState(address reward) external isInitialized whenNotPaused {
if(reward == address(0)) revert Errors.AddressZero();
_updateRewardState(reward);
}
function updateAllRewardState() external isInitialized whenNotPaused {
_updateAllRewardStates();
}
function queueRewards(address rewardToken, uint256 amount)
external
nonReentrant
isInitialized
whenNotPaused
onlyRewardDepositors
returns(bool)
{
if(amount == 0) revert Errors.NullAmount();
if(rewardToken == address(0)) revert Errors.AddressZero();
RewardState storage state = rewardStates[rewardToken];
if(state.lastUpdate == 0) {
rewardList.push(rewardToken);
}
_updateRewardState(rewardToken);
uint256 totalQueued = amount + state.queuedRewardAmount;
if(block.timestamp >= state.distributionEndTimestamp){
_updateRewardDistribution(rewardToken, state, totalQueued);
state.queuedRewardAmount = 0;
return true;
}
uint256 currentRemainingAmount = state.ratePerSecond * (state.distributionEndTimestamp - block.timestamp);
uint256 queuedAmountRatio = (totalQueued * MAX_BPS) / (totalQueued + currentRemainingAmount);
if(queuedAmountRatio >= UPDATE_REWARD_RATIO) {
_updateRewardDistribution(rewardToken, state, totalQueued);
state.queuedRewardAmount = 0;
} else {
state.queuedRewardAmount = totalQueued;
}
return true;
}
function _updateRewardDistribution(address rewardToken, RewardState storage state, uint256 rewardAmount) internal {
if(block.timestamp < state.distributionEndTimestamp) {
uint256 remainingRewards = state.ratePerSecond * (state.distributionEndTimestamp - block.timestamp);
rewardAmount += remainingRewards;
}
state.ratePerSecond = rewardAmount / DISTRIBUTION_DURATION;
state.currentRewardAmount = rewardAmount;
state.lastUpdate = safe128(block.timestamp);
uint256 distributionEnd = block.timestamp + DISTRIBUTION_DURATION;
state.distributionEndTimestamp = safe128(distributionEnd);
emit NewRewards(rewardToken, rewardAmount, distributionEnd);
}
function _getCurrentIndex() internal view returns(uint256) {
if(totalScaledAmount == 0) return INITIAL_INDEX;
return totalAssets().rayDiv(totalScaledAmount);
}
function _getNewRewardPerToken(address reward) internal view returns(uint256) {
RewardState storage state = rewardStates[reward];
if(totalScaledAmount == 0) return state.rewardPerToken;
uint256 lastRewardTimetamp = lastRewardUpdateTimestamp(reward);
if(state.lastUpdate == lastRewardTimetamp) return state.rewardPerToken;
return state.rewardPerToken + (
(((lastRewardTimetamp - state.lastUpdate) * state.ratePerSecond) * UNIT) / totalScaledAmount
);
}
function _getUserEarnedRewards(address reward, address user, uint256 currentRewardPerToken) internal view returns(uint256) {
UserRewardState storage userState = rewardStates[reward].userStates[user];
uint256 userScaledBalance = userScaledBalances[user];
if(userScaledBalance == 0) return 0;
return (userScaledBalance * (currentRewardPerToken - userState.lastRewardPerToken)) / UNIT;
}
function _updateRewardState(address reward) internal {
RewardState storage state = rewardStates[reward];
state.rewardPerToken = _getNewRewardPerToken(reward);
state.lastUpdate = safe128(lastRewardUpdateTimestamp(reward));
}
function _updateUserRewardState(address reward, address user) internal {
_updateRewardState(reward);
UserRewardState storage userState = rewardStates[reward].userStates[user];
uint256 currentRewardPerToken = rewardStates[reward].rewardPerToken;
userState.accruedRewards += _getUserEarnedRewards(reward, user, currentRewardPerToken);
userState.lastRewardPerToken = currentRewardPerToken;
}
function _updateAllRewardStates() internal {
address[] memory _rewards = rewardList;
uint256 length = _rewards.length;
for(uint256 i; i < length;){
_updateRewardState(_rewards[i]);
unchecked{ ++i; }
}
}
function _updateAllUserRewardStates(address user) internal {
address[] memory _rewards = rewardList;
uint256 length = _rewards.length;
for(uint256 i; i < length;){
_updateUserRewardState(_rewards[i], user);
unchecked{ ++i; }
}
}
function _claimRewards(address reward, address user, address receiver) internal returns(uint256) {
_updateUserRewardState(reward, user);
UserRewardState storage userState = rewardStates[reward].userStates[user];
uint256 rewardAmount = userState.accruedRewards;
if(rewardAmount == 0) return 0;
userState.accruedRewards = 0;
IERC20(reward).safeTransfer(receiver, rewardAmount);
emit ClaimedRewards(reward, user, receiver, rewardAmount);
return rewardAmount;
}
function _claimAllRewards(address user, address receiver) internal returns(UserClaimedRewards[] memory) {
address[] memory rewards = rewardList;
uint256 rewardsLength = rewards.length;
UserClaimedRewards[] memory rewardAmounts = new UserClaimedRewards[](rewardsLength);
_updateAllUserRewardStates(user);
for(uint256 i; i < rewardsLength; ++i){
UserRewardState storage userState = rewardStates[rewards[i]].userStates[user];
uint256 rewardAmount = userState.accruedRewards;
if(rewardAmount == 0) continue;
rewardAmounts[i].reward = rewards[i];
rewardAmounts[i].amount = rewardAmount;
userState.accruedRewards = 0;
IERC20(rewards[i]).safeTransfer(receiver, rewardAmount);
emit ClaimedRewards(rewards[i], user, receiver, rewardAmounts[i].amount);
}
return rewardAmounts;
}
function pause() external onlyOwner {
_pause();
}
function unpause() external onlyOwner {
_unpause();
}
function addRewardDepositor(address depositor) external onlyOwner {
if(depositor == address(0)) revert Errors.AddressZero();
if(rewardDepositors[depositor]) revert Errors.AlreadyListedDepositor();
rewardDepositors[depositor] = true;
emit AddedRewardDepositor(depositor);
}
function removeRewardDepositor(address depositor) external onlyOwner {
if(depositor == address(0)) revert Errors.AddressZero();
if(!rewardDepositors[depositor]) revert Errors.NotListedDepositor();
rewardDepositors[depositor] = false;
emit RemovedRewardDepositor(depositor);
}
function setUserAllowedClaimer(address user, address claimer) external onlyOwner {
if(user == address(0) || claimer == address(0)) revert Errors.AddressZero();
allowedClaimer[user] = claimer;
emit SetUserAllowedClaimer(user, claimer);
}
function safe128(uint256 n) internal pure returns (uint128) {
if(n > type(uint128).max) revert Errors.NumberExceed128Bits();
return uint128(n);
}
}文件 4 的 18：DullahanVault.sol
pragma solidity 0.8.16;
import "./base/ScalingERC20.sol";
import "./interfaces/IERC4626.sol";
import "./oz/interfaces/IERC20.sol";
import "./oz/libraries/SafeERC20.sol";
import "./oz/utils/ReentrancyGuard.sol";
import "./oz/utils/Pausable.sol";
import "./interfaces/IStakedAave.sol";
import "./interfaces/IGovernancePowerDelegationToken.sol";
import {Errors} from "./utils/Errors.sol";
import {WadRayMath} from "./utils/WadRayMath.sol";
contract DullahanVault is IERC4626, ScalingERC20, ReentrancyGuard, Pausable {
using SafeERC20 for IERC20;
using WadRayMath for uint256;
uint256 public constant MAX_BPS = 10000;
uint256 public constant MAX_UINT256 = 2**256 - 1;
uint256 private constant SEED_DEPOSIT = 0.001 ether;
address public immutable STK_AAVE;
address public immutable AAVE;
struct PodsManager {
bool rentingAllowed;
uint248 totalRented;
}
bool public initialized;
address public admin;
address public pendingAdmin;
uint256 public totalRentedAmount;
mapping(address => PodsManager) public podManagers;
address public votingPowerManager;
address public proposalPowerManager;
uint256 public bufferRatio = 500;
uint256 public reserveAmount;
uint256 public reserveRatio;
address public reserveManager;
event Initialized();
event RentToPod(address indexed manager, address indexed pod, uint256 amount);
event NotifyRentedAmount(address indexed manager, address indexed pod, uint256 addedAmount);
event PullFromPod(address indexed manager, address indexed pod, uint256 amount);
event AdminTransferred(
address indexed previousAdmin,
address indexed newAdmin
);
event NewPendingAdmin(
address indexed previousPendingAdmin,
address indexed newPendingAdmin
);
event NewPodManager(address indexed newManager);
event BlockedPodManager(address indexed manager);
event ReserveDeposit(address indexed from, uint256 amount);
event ReserveWithdraw(address indexed to, uint256 amount);
event UpdatedVotingPowerManager(address indexed oldManager, address indexed newManager);
event UpdatedProposalPowerManager(address indexed oldManager, address indexed newManager);
event UpdatedReserveManager(address indexed oldManager, address indexed newManager);
event UpdatedBufferRatio(uint256 oldRatio, uint256 newRatio);
event UpdatedReserveRatio(uint256 oldRatio, uint256 newRatio);
event TokenRecovered(address indexed token, uint256 amount);
modifier onlyAdmin() {
if (msg.sender != admin) revert Errors.CallerNotAdmin();
_;
}
modifier onlyAllowed() {
if (msg.sender != admin && msg.sender != reserveManager) revert Errors.CallerNotAdmin();
_;
}
modifier isInitialized() {
if (!initialized) revert Errors.NotInitialized();
_;
}
constructor(
address _admin,
uint256 _reserveRatio,
address _reserveManager,
address _aave,
address _stkAave,
string memory _name,
string memory _symbol
) ScalingERC20(_name, _symbol) {
if(_admin == address(0) || _reserveManager == address(0) || _aave == address(0) || _stkAave == address(0)) revert Errors.AddressZero();
if(_reserveRatio == 0) revert Errors.NullAmount();
admin = _admin;
reserveRatio = _reserveRatio;
reserveManager = _reserveManager;
AAVE = _aave;
STK_AAVE = _stkAave;
}
function init(address _votingPowerManager, address _proposalPowerManager) external onlyAdmin {
if(initialized) revert Errors.AlreadyInitialized();
initialized = true;
votingPowerManager = _votingPowerManager;
proposalPowerManager = _proposalPowerManager;
_deposit(
SEED_DEPOSIT,
msg.sender,
msg.sender
);
IGovernancePowerDelegationToken(STK_AAVE).delegateByType(
_votingPowerManager,
IGovernancePowerDelegationToken.DelegationType.VOTING_POWER
);
IGovernancePowerDelegationToken(STK_AAVE).delegateByType(
_proposalPowerManager,
IGovernancePowerDelegationToken.DelegationType.PROPOSITION_POWER
);
emit Initialized();
}
function asset() external view returns (address) {
return STK_AAVE;
}
function totalAssets() public view returns (uint256) {
return
IERC20(STK_AAVE).balanceOf(address(this)) +
totalRentedAmount -
reserveAmount;
}
function totalSupply()
public
view
override(ScalingERC20, IERC20)
returns (uint256)
{
return totalAssets();
}
function totalAvailable() public view returns (uint256) {
uint256 availableBalance = IERC20(STK_AAVE).balanceOf(address(this));
availableBalance = reserveAmount >= availableBalance ? 0 : availableBalance - reserveAmount;
uint256 bufferAmount = (totalAssets() * bufferRatio) / MAX_BPS;
return availableBalance > bufferAmount ? availableBalance - bufferAmount : 0;
}
function convertToShares(uint256 assets) public pure returns (uint256) {
return assets;
}
function convertToAssets(uint256 shares) public pure returns (uint256) {
return shares;
}
function previewDeposit(uint256 assets) public pure returns (uint256) {
return assets;
}
function previewMint(uint256 shares) public pure returns (uint256) {
return shares;
}
function previewWithdraw(uint256 assets) public pure returns (uint256) {
return assets;
}
function previewRedeem(uint256 shares) public pure returns (uint256) {
return shares;
}
function maxDeposit(address user) public view returns (uint256) {
return type(uint256).max;
}
function maxMint(address user) public view returns (uint256) {
return type(uint256).max;
}
function maxWithdraw(address owner) public view returns (uint256) {
return balanceOf(owner);
}
function maxRedeem(address owner) public view returns (uint256) {
return balanceOf(owner);
}
function getCurrentIndex() public view returns(uint256) {
return _getCurrentIndex();
}
function getDelegates() external view returns(address votingPower, address proposalPower) {
return (votingPowerManager, proposalPowerManager);
}
function deposit(
uint256 assets,
address receiver
) public isInitialized nonReentrant whenNotPaused returns (uint256 shares) {
(assets, shares) = _deposit(assets, receiver, msg.sender);
emit Deposit(msg.sender, receiver, assets, shares);
}
function mint(
uint256 shares,
address receiver
) public isInitialized nonReentrant whenNotPaused returns (uint256 assets) {
(assets, shares) = _deposit(shares, receiver, msg.sender);
emit Deposit(msg.sender, receiver, assets, shares);
}
function withdraw(
uint256 assets,
address receiver,
address owner
) public isInitialized nonReentrant returns (uint256 shares) {
(uint256 _withdrawn, uint256 _burntShares) = _withdraw(
assets,
owner,
receiver,
msg.sender
);
emit Withdraw(msg.sender, receiver, owner, _withdrawn, _burntShares);
return _burntShares;
}
function redeem(
uint256 shares,
address receiver,
address owner
) public isInitialized nonReentrant returns (uint256 assets) {
(uint256 _withdrawn, uint256 _burntShares) = _withdraw(
shares,
owner,
receiver,
msg.sender
);
emit Withdraw(msg.sender, receiver, owner, _withdrawn, _burntShares);
return _withdrawn;
}
function updateStkAaveRewards() external nonReentrant {
_getStkAaveRewards();
}
function rentStkAave(address pod, uint256 amount) external nonReentrant {
address manager = msg.sender;
if(!podManagers[manager].rentingAllowed) revert Errors.CallerNotAllowedManager();
if(pod == address(0)) revert Errors.AddressZero();
if(amount == 0) revert Errors.NullAmount();
_getStkAaveRewards();
IERC20 _stkAave = IERC20(STK_AAVE);
uint256 availableBalance = _stkAave.balanceOf(address(this));
availableBalance = reserveAmount >= availableBalance ? 0 : availableBalance - reserveAmount;
uint256 bufferAmount = (totalAssets() * bufferRatio) / MAX_BPS;
if(availableBalance < bufferAmount) revert Errors.WithdrawBuffer();
if(amount > (availableBalance - bufferAmount)) revert Errors.NotEnoughAvailableFunds();
podManagers[manager].totalRented += safe248(amount);
totalRentedAmount += amount;
_stkAave.safeTransfer(pod, amount);
emit RentToPod(manager, pod, amount);
}
function notifyRentedAmount(address pod, uint256 addedAmount) external nonReentrant {
address manager = msg.sender;
if(podManagers[manager].totalRented == 0) revert Errors.NotUndebtedManager();
if(pod == address(0)) revert Errors.AddressZero();
if(addedAmount == 0) revert Errors.NullAmount();
podManagers[manager].totalRented += safe248(addedAmount);
totalRentedAmount += addedAmount;
reserveAmount += (addedAmount * reserveRatio) / MAX_BPS;
emit NotifyRentedAmount(manager, pod, addedAmount);
}
function pullRentedStkAave(address pod, uint256 amount) external nonReentrant {
address manager = msg.sender;
if(podManagers[manager].totalRented == 0) revert Errors.NotUndebtedManager();
if(pod == address(0)) revert Errors.AddressZero();
if(amount == 0) revert Errors.NullAmount();
if(amount > podManagers[manager].totalRented) revert Errors.AmountExceedsDebt();
_getStkAaveRewards();
podManagers[manager].totalRented -= safe248(amount);
totalRentedAmount -= amount;
IERC20(STK_AAVE).safeTransferFrom(pod, address(this), amount);
emit PullFromPod(manager, pod, amount);
}
function _getCurrentIndex() internal view override returns (uint256) {
if(_totalSupply == 0) return INITIAL_INDEX;
return totalAssets().rayDiv(_totalSupply);
}
function _deposit(
uint256 amount,
address receiver,
address depositor
) internal returns (uint256, uint256) {
if (receiver == address(0)) revert Errors.AddressZero();
if (amount == 0) revert Errors.NullAmount();
_getStkAaveRewards();
uint256 _currentIndex = _getCurrentIndex();
IERC20(STK_AAVE).safeTransferFrom(depositor, address(this), amount);
uint256 minted = _mint(receiver, amount, _currentIndex);
afterDeposit(amount);
return (amount, minted);
}
function _withdraw(
uint256 amount,
address owner,
address receiver,
address sender
) internal returns (uint256, uint256) {
if (receiver == address(0) || owner == address(0)) revert Errors.AddressZero();
if (amount == 0) revert Errors.NullAmount();
_getStkAaveRewards();
bool _maxWithdraw;
if(amount == MAX_UINT256) {
amount = balanceOf(owner);
_maxWithdraw = true;
}
if (owner != sender) {
uint256 allowed = _allowances[owner][sender];
if (allowed < amount) revert Errors.ERC20_AmountOverAllowance();
if (allowed != type(uint256).max)
_allowances[owner][sender] = allowed - amount;
}
IERC20 _stkAave = IERC20(STK_AAVE);
uint256 availableBalance = _stkAave.balanceOf(address(this));
availableBalance = reserveAmount >= availableBalance ? 0 : availableBalance - reserveAmount;
if(amount > availableBalance) revert Errors.NotEnoughAvailableFunds();
uint256 burned = _burn(owner, amount, _maxWithdraw);
beforeWithdraw(amount);
_stkAave.safeTransfer(receiver, amount);
return (amount, burned);
}
function beforeWithdraw(uint256 amount) internal {}
function afterDeposit(uint256 amount) internal {}
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal isInitialized whenNotPaused override virtual {
super._beforeTokenTransfer(from, to, amount);
}
function _afterTokenTransfer(
address from,
address to,
uint256 amount
) internal override virtual {
super._afterTokenTransfer(from, to, amount);
}
function _getStkAaveRewards() internal {
IStakedAave _stkAave = IStakedAave(STK_AAVE);
uint256 pendingRewards = _stkAave.getTotalRewardsBalance(address(this));
if (pendingRewards > 0) {
_stkAave.claimRewards(address(this), pendingRewards);
reserveAmount += (pendingRewards * reserveRatio) / MAX_BPS;
}
IERC20 _aave = IERC20(AAVE);
uint256 currentBalance = _aave.balanceOf(address(this));
if(currentBalance > 0) {
_aave.safeIncreaseAllowance(STK_AAVE, currentBalance);
_stkAave.stake(address(this), currentBalance);
}
}
function pause() external onlyAdmin {
_pause();
}
function unpause() external onlyAdmin {
_unpause();
}
function transferAdmin(address newAdmin) external onlyAdmin {
if (newAdmin == address(0)) revert Errors.AddressZero();
if (newAdmin == admin) revert Errors.CannotBeAdmin();
address oldPendingAdmin = pendingAdmin;
pendingAdmin = newAdmin;
emit NewPendingAdmin(oldPendingAdmin, newAdmin);
}
function acceptAdmin() external {
if (msg.sender != pendingAdmin) revert Errors.CallerNotPendingAdmin();
address newAdmin = pendingAdmin;
address oldAdmin = admin;
admin = newAdmin;
pendingAdmin = address(0);
emit AdminTransferred(oldAdmin, newAdmin);
emit NewPendingAdmin(newAdmin, address(0));
}
function addPodManager(address newManager) external onlyAdmin {
if(newManager == address(0)) revert Errors.AddressZero();
if(podManagers[newManager].rentingAllowed) revert Errors.ManagerAlreadyListed();
podManagers[newManager].rentingAllowed = true;
emit NewPodManager(newManager);
}
function blockPodManager(address manager) external onlyAdmin {
if(manager == address(0)) revert Errors.AddressZero();
if(!podManagers[manager].rentingAllowed) revert Errors.ManagerNotListed();
podManagers[manager].rentingAllowed = false;
emit BlockedPodManager(manager);
}
function updateVotingPowerManager(address newManager) external onlyAdmin {
if(newManager == address(0)) revert Errors.AddressZero();
if(newManager == votingPowerManager) revert Errors.SameAddress();
address oldManager = votingPowerManager;
votingPowerManager = newManager;
IGovernancePowerDelegationToken(STK_AAVE).delegateByType(
newManager,
IGovernancePowerDelegationToken.DelegationType.VOTING_POWER
);
emit UpdatedVotingPowerManager(oldManager, newManager);
}
function updateProposalPowerManager(address newManager) external onlyAdmin {
if(newManager == address(0)) revert Errors.AddressZero();
if(newManager == proposalPowerManager) revert Errors.SameAddress();
address oldManager = proposalPowerManager;
proposalPowerManager = newManager;
IGovernancePowerDelegationToken(STK_AAVE).delegateByType(
newManager,
IGovernancePowerDelegationToken.DelegationType.PROPOSITION_POWER
);
emit UpdatedProposalPowerManager(oldManager, newManager);
}
function updateReserveManager(address newManager) external onlyAdmin {
if(newManager == address(0)) revert Errors.AddressZero();
if(newManager == reserveManager) revert Errors.SameAddress();
address oldManager = reserveManager;
reserveManager = newManager;
emit UpdatedReserveManager(oldManager, newManager);
}
function updateReserveRatio(uint256 newRatio) external onlyAdmin {
if(newRatio > 1500) revert Errors.InvalidParameter();
uint256 oldRatio = reserveRatio;
reserveRatio = newRatio;
emit UpdatedReserveRatio(oldRatio, newRatio);
}
function updateBufferRatio(uint256 newRatio) external onlyAdmin {
if(newRatio > 1500) revert Errors.InvalidParameter();
uint256 oldRatio = bufferRatio;
bufferRatio = newRatio;
emit UpdatedBufferRatio(oldRatio, newRatio);
}
function depositToReserve(uint256 amount) external nonReentrant onlyAllowed returns(bool) {
if(amount == 0) revert Errors.NullAmount();
_getStkAaveRewards();
IERC20(STK_AAVE).safeTransferFrom(msg.sender, address(this), amount);
reserveAmount += amount;
emit ReserveDeposit(msg.sender, amount);
return true;
}
function withdrawFromReserve(uint256 amount, address receiver) external nonReentrant onlyAllowed returns(bool) {
if(amount == 0) revert Errors.NullAmount();
if(receiver == address(0)) revert Errors.AddressZero();
if(amount > reserveAmount) revert Errors.ReserveTooLow();
_getStkAaveRewards();
IERC20(STK_AAVE).safeTransfer(receiver, amount);
reserveAmount -= amount;
emit ReserveWithdraw(receiver, amount);
return true;
}
function recoverERC20(address token) external onlyAdmin returns(bool) {
if(token == AAVE || token == STK_AAVE) revert Errors.CannotRecoverToken();
uint256 amount = IERC20(token).balanceOf(address(this));
if(amount == 0) revert Errors.NullAmount();
IERC20(token).safeTransfer(admin, amount);
emit TokenRecovered(token, amount);
return true;
}
function safe248(uint256 n) internal pure returns (uint248) {
if(n > type(uint248).max) revert Errors.NumberExceed248Bits();
return uint248(n);
}
}文件 5 的 18：DullahanZapDeposit.sol
pragma solidity 0.8.16;
import "../DullahanVault.sol";
import "../DullahanRewardsStaking.sol";
import "../interfaces/IStakedAave.sol";
import "../utils/Owner.sol";
import "../oz/utils/ReentrancyGuard.sol";
import "../oz/utils/Pausable.sol";
import "../oz/interfaces/IERC20.sol";
import "../oz/libraries/SafeERC20.sol";
import {Errors} from "../utils/Errors.sol";
contract DullahanZapDeposit is Owner, Pausable {
using SafeERC20 for IERC20;
address public immutable aave;
address public immutable stkAave;
address public immutable vault;
address public immutable staking;
event ZapDeposit(address indexed caller, address indexed receiver, address indexed sourceToken, uint256 amount, bool staked);
event TokenRecovered(address indexed token, uint256 amount);
constructor(
address _aave,
address _stkAave,
address _vault,
address _staking
) {
if(_aave == address(0) || _stkAave == address(0) || _vault == address(0) || _staking == address(0)) revert Errors.AddressZero();
aave = _aave;
stkAave = _stkAave;
vault = _vault;
staking = _staking;
}
function zapDeposit(address sourceToken, uint256 amount, address receiver, bool stake) external whenNotPaused {
if(sourceToken == address(0) || receiver == address(0)) revert Errors.AddressZero();
if(amount == 0) revert Errors.NullAmount();
if(sourceToken != aave && sourceToken != stkAave) revert Errors.InvalidSourceToken();
IERC20(sourceToken).safeTransferFrom(msg.sender, address(this), amount);
if(sourceToken == aave) {
IERC20(aave).safeIncreaseAllowance(stkAave, amount);
IStakedAave(stkAave).stake(address(this), amount);
}
IERC20(stkAave).safeIncreaseAllowance(vault, amount);
if(stake) {
uint256 shares = DullahanVault(vault).deposit(amount, address(this));
if(shares != amount) revert Errors.DepositFailed();
IERC20(vault).safeIncreaseAllowance(staking, amount);
DullahanRewardsStaking(staking).stake(amount, receiver);
} else {
uint256 shares = DullahanVault(vault).deposit(amount, receiver);
if(shares != amount) revert Errors.DepositFailed();
}
emit ZapDeposit(msg.sender, receiver, sourceToken, amount, stake);
}
function pause() external onlyOwner {
_pause();
}
function unpause() external onlyOwner {
_unpause();
}
function recoverERC20(address token) external onlyOwner returns(bool) {
uint256 amount = IERC20(token).balanceOf(address(this));
if(amount == 0) revert Errors.NullAmount();
IERC20(token).safeTransfer(msg.sender, amount);
emit TokenRecovered(token, amount);
return true;
}
}文件 6 的 18：Errors.sol
pragma solidity 0.8.16;
library Errors {
error AddressZero();
error NullAmount();
error IncorrectRewardToken();
error SameAddress();
error InequalArraySizes();
error EmptyArray();
error EmptyParameters();
error NotInitialized();
error AlreadyInitialized();
error CannotInitialize();
error InvalidParameter();
error CannotRecoverToken();
error NullWithdraw();
error AlreadyListedManager();
error NotListedManager();
error CallerNotAdmin();
error CannotBeAdmin();
error CallerNotPendingAdmin();
error CallerNotAllowed();
error ERC20_ApproveAddressZero();
error ERC20_AllowanceUnderflow();
error ERC20_AmountOverAllowance();
error ERC20_AddressZero();
error ERC20_SelfTransfer();
error ERC20_NullAmount();
error ERC20_AmountExceedBalance();
error NumberExceed96Bits();
error NumberExceed128Bits();
error NumberExceed248Bits();
error ManagerAlreadyListed();
error ManagerNotListed();
error NotEnoughAvailableFunds();
error WithdrawBuffer();
error ReserveTooLow();
error CallerNotAllowedManager();
error NotUndebtedManager();
error AmountExceedsDebt();
error NullScaledAmount();
error AlreadyListedDepositor();
error NotListedDepositor();
error ClaimNotAllowed();
error NotPodOwner();
error NotPodManager();
error FailPodStateUpdate();
error MintAmountUnderMinimum();
error RepayFailed();
error CallerNotValidPod();
error CollateralBlocked();
error MintingAllowanceFailed();
error FreeingStkAaveFailed();
error CollateralAlreadyListed();
error CollateralNotListed();
error CollateralNotAllowed();
error PodInvalid();
error FailStateUpdate();
error PodNotLiquidable();
error VaultAlreadySet();
error InvalidSourceToken();
error DepositFailed();
error NullConvertedAmount();
}文件 7 的 18：IERC20.sol
pragma solidity ^0.8.0;
interface IERC20 {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address from,
address to,
uint256 amount
) external returns (bool);
}文件 8 的 18：IERC4626.sol
pragma solidity 0.8.16;
import "../oz/interfaces/IERC20.sol";
interface IERC4626 is IERC20 {
event Deposit(
address indexed caller,
address indexed owner,
uint256 assets,
uint256 shares
);
event Withdraw(
address indexed caller,
address indexed receiver,
address indexed owner,
uint256 assets,
uint256 shares
);
function asset() external view returns (address);
function deposit(uint256 assets, address receiver)
external
returns (uint256 shares);
function mint(uint256 shares, address receiver)
external
returns (uint256 assets);
function withdraw(
uint256 assets,
address receiver,
address owner
) external returns (uint256 shares);
function redeem(
uint256 shares,
address receiver,
address owner
) external returns (uint256 assets);
function totalAssets() external view returns (uint256);
function convertToShares(uint256 assets) external view returns (uint256);
function convertToAssets(uint256 shares) external view returns (uint256);
function previewDeposit(uint256 assets) external view returns (uint256);
function previewMint(uint256 shares) external view returns (uint256);
function previewWithdraw(uint256 assets) external view returns (uint256);
function previewRedeem(uint256 shares) external view returns (uint256);
function maxDeposit(address) external view returns (uint256);
function maxMint(address) external view returns (uint256);
function maxWithdraw(address owner) external view returns (uint256);
function maxRedeem(address owner) external view returns (uint256);
}
文件 9 的 18：IGovernancePowerDelegationToken.sol
pragma solidity 0.8.16;
interface IGovernancePowerDelegationToken {
enum DelegationType {
VOTING_POWER,
PROPOSITION_POWER
}
event DelegateChanged(
address indexed delegator,
address indexed delegatee,
DelegationType delegationType
);
event DelegatedPowerChanged(
address indexed user,
uint256 amount,
DelegationType delegationType
);
function delegateByType(address delegatee, DelegationType delegationType)
external;
function delegate(address delegatee) external;
function getDelegateeByType(
address delegator,
DelegationType delegationType
) external view returns (address);
function getPowerCurrent(address user, DelegationType delegationType)
external
view
returns (uint256);
function getPowerAtBlock(
address user,
uint256 blockNumber,
DelegationType delegationType
) external view returns (uint256);
function totalSupplyAt(uint256 blockNumber) external view returns (uint256);
}
文件 10 的 18：IScalingERC20.sol
pragma solidity 0.8.16;
interface IScalingERC20 {
function totalSupply() external view returns (uint256);
function totalScaledSupply() external view returns (uint256);
function balanceOf(address user) external view returns (uint256);
function scaledBalanceOf(address user) external view returns (uint256);
}文件 11 的 18：IStakedAave.sol
pragma solidity 0.8.16;
interface IStakedAave {
event Staked(
address indexed from,
address indexed to,
uint256 assets,
uint256 shares
);
event Redeem(
address indexed from,
address indexed to,
uint256 assets,
uint256 shares
);
event RewardsAccrued(address user, uint256 amount);
event RewardsClaimed(address indexed from, address indexed to, uint256 amount);
event Cooldown(address indexed user);
function stake(address to, uint256 amount) external;
function redeem(address to, uint256 amount) external;
function cooldown() external;
function claimRewards(address to, uint256 amount) external;
function getTotalRewardsBalance(address staker) external view returns (uint256);
}文件 12 的 18：Ownable.sol
pragma solidity ^0.8.0;
import "./Context.sol";
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
_transferOwnership(_msgSender());
}
modifier onlyOwner() {
_checkOwner();
_;
}
function owner() public view virtual returns (address) {
return _owner;
}
function _checkOwner() internal view virtual {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
}
function renounceOwnership() public virtual onlyOwner {
_transferOwnership(address(0));
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal virtual {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}文件 13 的 18：Owner.sol
pragma solidity 0.8.16;
import "../oz/utils/Ownable.sol";
contract Owner is Ownable {
address public pendingOwner;
event NewPendingOwner(address indexed previousPendingOwner, address indexed newPendingOwner);
error CannotBeOwner();
error CallerNotPendingOwner();
error OwnerAddressZero();
function transferOwnership(address newOwner) public override virtual onlyOwner {
if(newOwner == address(0)) revert OwnerAddressZero();
if(newOwner == owner()) revert CannotBeOwner();
address oldPendingOwner = pendingOwner;
pendingOwner = newOwner;
emit NewPendingOwner(oldPendingOwner, newOwner);
}
function acceptOwnership() public virtual {
if(msg.sender != pendingOwner) revert CallerNotPendingOwner();
address newOwner = pendingOwner;
_transferOwnership(pendingOwner);
pendingOwner = address(0);
emit NewPendingOwner(newOwner, address(0));
}
}文件 14 的 18：Pausable.sol
pragma solidity ^0.8.0;
import "./Context.sol";
abstract contract Pausable is Context {
event Paused(address account);
event Unpaused(address account);
bool private _paused;
constructor() {
_paused = false;
}
modifier whenNotPaused() {
_requireNotPaused();
_;
}
modifier whenPaused() {
_requirePaused();
_;
}
function paused() public view virtual returns (bool) {
return _paused;
}
function _requireNotPaused() internal view virtual {
require(!paused(), "Pausable: paused");
}
function _requirePaused() internal view virtual {
require(paused(), "Pausable: not paused");
}
function _pause() internal virtual whenNotPaused {
_paused = true;
emit Paused(_msgSender());
}
function _unpause() internal virtual whenPaused {
_paused = false;
emit Unpaused(_msgSender());
}
}文件 15 的 18：ReentrancyGuard.sol
pragma solidity ^0.8.0;
abstract contract ReentrancyGuard {
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
constructor() {
_status = _NOT_ENTERED;
}
modifier nonReentrant() {
require(_status != _ENTERED, "ReentrancyGuard: reentrant call");
_status = _ENTERED;
_;
_status = _NOT_ENTERED;
}
}文件 16 的 18：SafeERC20.sol
pragma solidity ^0.8.0;
import "../interfaces/IERC20.sol";
import "../utils/Address.sol";
library SafeERC20 {
using Address for address;
function safeTransfer(
IERC20 token,
address to,
uint256 value
) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(
IERC20 token,
address from,
address to,
uint256 value
) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(
IERC20 token,
address spender,
uint256 value
) internal {
require(
(value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance"
);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(
IERC20 token,
address spender,
uint256 value
) internal {
uint256 newAllowance = token.allowance(address(this), spender) + value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(
IERC20 token,
address spender,
uint256 value
) internal {
unchecked {
uint256 oldAllowance = token.allowance(address(this), spender);
require(oldAllowance >= value, "SafeERC20: decreased allowance below zero");
uint256 newAllowance = oldAllowance - value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) {
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}文件 17 的 18：ScalingERC20.sol
pragma solidity 0.8.16;
import "../oz/interfaces/IERC20.sol";
import "../oz/utils/Context.sol";
import {Errors} from "../utils/Errors.sol";
import {WadRayMath} from "../utils/WadRayMath.sol";
abstract contract ScalingERC20 is Context, IERC20 {
using WadRayMath for uint256;
uint256 public constant UNIT = 1e18;
uint256 internal constant INITIAL_INDEX = 1e27;
struct UserState {
uint128 scaledBalance;
uint128 index;
}
uint256 internal _totalSupply;
mapping(address => mapping(address => uint256)) internal _allowances;
string private _name;
string private _symbol;
uint8 private _decimals;
mapping(address => UserState) internal _userStates;
event Mint(address indexed user, uint256 scaledAmount, uint256 index);
event Burn(address indexed user, uint256 scaledAmount, uint256 index);
constructor(
string memory __name,
string memory __symbol
) {
_name = __name;
_symbol = __symbol;
_decimals = 18;
}
function name() public view returns (string memory) {
return _name;
}
function symbol() external view returns (string memory) {
return _symbol;
}
function decimals() external view returns (uint8) {
return _decimals;
}
function totalSupply() public view override virtual returns (uint256) {
uint256 _scaledSupply = _totalSupply;
if(_scaledSupply == 0) return 0;
return _scaledSupply.rayMul(_getCurrentIndex());
}
function balanceOf(address account) public view override virtual returns (uint256) {
return uint256(_userStates[account].scaledBalance).rayMul(_getCurrentIndex());
}
function totalScaledSupply() public view virtual returns (uint256) {
return _totalSupply;
}
function scaledBalanceOf(address account) public view virtual returns (uint256) {
return _userStates[account].scaledBalance;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(msg.sender, spender, amount);
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
address owner = msg.sender;
_approve(owner, spender, allowance(owner, spender) + addedValue);
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
address owner = msg.sender;
uint256 currentAllowance = allowance(owner, spender);
if(currentAllowance < subtractedValue) revert Errors.ERC20_AllowanceUnderflow();
unchecked {
_approve(owner, spender, currentAllowance - subtractedValue);
}
return true;
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(msg.sender, recipient, amount);
emit Transfer(msg.sender, recipient, amount);
return true;
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public virtual override returns (bool) {
uint256 _allowance = _allowances[sender][msg.sender];
if(_allowance < amount) revert Errors.ERC20_AmountOverAllowance();
if(_allowance != type(uint256).max) {
_approve(
sender,
msg.sender,
_allowances[sender][msg.sender] - amount
);
}
_transfer(sender, recipient, amount);
emit Transfer(sender, recipient, amount);
return true;
}
function _getCurrentIndex() internal virtual view returns(uint256) {}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
if(owner == address(0) || spender == address(0)) revert Errors.ERC20_ApproveAddressZero();
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(
address sender,
address recipient,
uint256 amount
) internal virtual {
if(sender == address(0) || recipient == address(0)) revert Errors.ERC20_AddressZero();
if(sender == recipient) revert Errors.ERC20_SelfTransfer();
if(amount == 0) revert Errors.ERC20_NullAmount();
uint128 _scaledAmount = safe128(amount.rayDiv(_getCurrentIndex()));
_transferScaled(sender, recipient, _scaledAmount);
}
function _transferScaled(
address sender,
address recipient,
uint128 scaledAmount
) internal virtual {
if(scaledAmount > _userStates[sender].scaledBalance) revert Errors.ERC20_AmountExceedBalance();
_beforeTokenTransfer(sender, recipient, scaledAmount);
unchecked {
_userStates[sender].scaledBalance -= scaledAmount;
_userStates[recipient].scaledBalance += scaledAmount;
}
_afterTokenTransfer(sender, recipient, scaledAmount);
}
function _mint(address account, uint256 amount, uint256 _currentIndex) internal virtual returns(uint256) {
uint256 _scaledAmount = amount.rayDiv(_currentIndex);
if(_scaledAmount == 0) revert Errors.ERC20_NullAmount();
_beforeTokenTransfer(address(0), account, _scaledAmount);
_userStates[account].index = safe128(_currentIndex);
_totalSupply += _scaledAmount;
_userStates[account].scaledBalance += safe128(_scaledAmount);
_afterTokenTransfer(address(0), account, _scaledAmount);
emit Mint(account, _scaledAmount, _currentIndex);
emit Transfer(address(0), account, amount);
return amount;
}
function _burn(address account, uint256 amount, bool maxWithdraw) internal virtual returns(uint256) {
uint256 _currentIndex = _getCurrentIndex();
uint256 _scaledBalance = _userStates[account].scaledBalance;
uint256 _scaledAmount = maxWithdraw ? _scaledBalance: amount.rayDiv(_currentIndex);
if(_scaledAmount == 0) revert Errors.ERC20_NullAmount();
if(_scaledAmount > _scaledBalance) revert Errors.ERC20_AmountExceedBalance();
_beforeTokenTransfer(account, address(0), _scaledAmount);
_userStates[account].index = safe128(_currentIndex);
_totalSupply -= _scaledAmount;
_userStates[account].scaledBalance -= safe128(_scaledAmount);
_afterTokenTransfer(account, address(0), _scaledAmount);
emit Burn(account, _scaledAmount, _currentIndex);
emit Transfer(account, address(0), amount);
return amount;
}
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
function _afterTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
function safe128(uint256 n) internal pure returns (uint128) {
if(n > type(uint128).max) revert Errors.NumberExceed128Bits();
return uint128(n);
}
}文件 18 的 18：WadRayMath.sol
pragma solidity ^0.8.0;
library WadRayMath {
uint256 internal constant WAD = 1e18;
uint256 internal constant HALF_WAD = 0.5e18;
uint256 internal constant RAY = 1e27;
uint256 internal constant HALF_RAY = 0.5e27;
uint256 internal constant WAD_RAY_RATIO = 1e9;
uint256 internal constant HALF_WAD_RAY_RATIO = 0.5e9;
uint256 internal constant MAX_UINT256 = 2**256 - 1;
uint256 internal constant MAX_UINT256_MINUS_HALF_WAD = 2**256 - 1 - 0.5e18;
uint256 internal constant MAX_UINT256_MINUS_HALF_RAY = 2**256 - 1 - 0.5e27;
function wadMul(uint256 x, uint256 y) internal pure returns (uint256 z) {
assembly {
if mul(y, gt(x, div(MAX_UINT256_MINUS_HALF_WAD, y))) {
revert(0, 0)
}
z := div(add(mul(x, y), HALF_WAD), WAD)
}
}
function wadDiv(uint256 x, uint256 y) internal pure returns (uint256 z) {
assembly {
z := div(y, 2)
if iszero(mul(y, iszero(gt(x, div(sub(MAX_UINT256, z), WAD))))) {
revert(0, 0)
}
z := div(add(mul(WAD, x), z), y)
}
}
function rayMul(uint256 x, uint256 y) internal pure returns (uint256 z) {
assembly {
if mul(y, gt(x, div(MAX_UINT256_MINUS_HALF_RAY, y))) {
revert(0, 0)
}
z := div(add(mul(x, y), HALF_RAY), RAY)
}
}
function rayDiv(uint256 x, uint256 y) internal pure returns (uint256 z) {
assembly {
z := div(y, 2)
if iszero(mul(y, iszero(gt(x, div(sub(MAX_UINT256, z), RAY))))) {
revert(0, 0)
}
z := div(add(mul(RAY, x), z), y)
}
}
function rayToWad(uint256 x) internal pure returns (uint256 y) {
assembly {
y := add(div(x, WAD_RAY_RATIO), iszero(lt(mod(x, WAD_RAY_RATIO), HALF_WAD_RAY_RATIO)))
}
}
function wadToRay(uint256 x) internal pure returns (uint256 y) {
assembly {
y := mul(WAD_RAY_RATIO, x)
if iszero(eq(div(y, WAD_RAY_RATIO), x)) {
revert(0, 0)
}
}
}
}{
"compilationTarget": {
"contracts/modules/DullahanZapDeposit.sol": "DullahanZapDeposit"
},
"evmVersion": "london",
"libraries": {},
"metadata": {
"bytecodeHash": "ipfs"
},
"optimizer": {
"enabled": true,
"runs": 200
},
"remappings": []
}[{"inputs":[{"internalType":"address","name":"_aave","type":"address"},{"internalType":"address","name":"_stkAave","type":"address"},{"internalType":"address","name":"_vault","type":"address"},{"internalType":"address","name":"_staking","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"AddressZero","type":"error"},{"inputs":[],"name":"CallerNotPendingOwner","type":"error"},{"inputs":[],"name":"CannotBeOwner","type":"error"},{"inputs":[],"name":"DepositFailed","type":"error"},{"inputs":[],"name":"InvalidSourceToken","type":"error"},{"inputs":[],"name":"NullAmount","type":"error"},{"inputs":[],"name":"OwnerAddressZero","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousPendingOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newPendingOwner","type":"address"}],"name":"NewPendingOwner","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Paused","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"token","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"TokenRecovered","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Unpaused","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"caller","type":"address"},{"indexed":true,"internalType":"address","name":"receiver","type":"address"},{"indexed":true,"internalType":"address","name":"sourceToken","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"},{"indexed":false,"internalType":"bool","name":"staked","type":"bool"}],"name":"ZapDeposit","type":"event"},{"inputs":[],"name":"aave","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"acceptOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"paused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pendingOwner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"}],"name":"recoverERC20","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"staking","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"stkAave","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"unpause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"vault","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"sourceToken","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"address","name":"receiver","type":"address"},{"internalType":"bool","name":"stake","type":"bool"}],"name":"zapDeposit","outputs":[],"stateMutability":"nonpayable","type":"function"}]
