编译器
0.8.25+commit.b61c2a91
文件 1 的 27：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");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResultFromTarget(target, 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) {
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResultFromTarget(target, 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) {
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
function verifyCallResultFromTarget(
address target,
bool success,
bytes memory returndata,
string memory errorMessage
) internal view returns (bytes memory) {
if (success) {
if (returndata.length == 0) {
require(isContract(target), "Address: call to non-contract");
}
return returndata;
} else {
_revert(returndata, errorMessage);
}
}
function verifyCallResult(
bool success,
bytes memory returndata,
string memory errorMessage
) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
_revert(returndata, errorMessage);
}
}
function _revert(bytes memory returndata, string memory errorMessage) private pure {
if (returndata.length > 0) {
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
文件 2 的 27：BaseStrategy.sol
pragma solidity >=0.8.18;
import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import {ITokenizedStrategy} from "./interfaces/ITokenizedStrategy.sol";
abstract contract BaseStrategy {
modifier onlySelf() {
_onlySelf();
_;
}
modifier onlyManagement() {
TokenizedStrategy.requireManagement(msg.sender);
_;
}
modifier onlyKeepers() {
TokenizedStrategy.requireKeeperOrManagement(msg.sender);
_;
}
modifier onlyEmergencyAuthorized() {
TokenizedStrategy.requireEmergencyAuthorized(msg.sender);
_;
}
function _onlySelf() internal view {
require(msg.sender == address(this), "!self");
}
address public constant tokenizedStrategyAddress =
0xBB51273D6c746910C7C06fe718f30c936170feD0;
ERC20 internal immutable asset;
ITokenizedStrategy internal immutable TokenizedStrategy;
constructor(address _asset, string memory _name) {
asset = ERC20(_asset);
TokenizedStrategy = ITokenizedStrategy(address(this));
_delegateCall(
abi.encodeCall(
ITokenizedStrategy.initialize,
(_asset, _name, msg.sender, msg.sender, msg.sender)
)
);
assembly {
sstore(
0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc,
tokenizedStrategyAddress
)
}
}
function _deployFunds(uint256 _amount) internal virtual;
function _freeFunds(uint256 _amount) internal virtual;
function _harvestAndReport()
internal
virtual
returns (uint256 _totalAssets);
function _tend(uint256 _totalIdle) internal virtual {}
function _tendTrigger() internal view virtual returns (bool) {
return false;
}
function tendTrigger() external view virtual returns (bool, bytes memory) {
return (
_tendTrigger(),
abi.encodeWithSelector(ITokenizedStrategy.tend.selector)
);
}
function availableDepositLimit(
address
) public view virtual returns (uint256) {
return type(uint256).max;
}
function availableWithdrawLimit(
address
) public view virtual returns (uint256) {
return type(uint256).max;
}
function _emergencyWithdraw(uint256 _amount) internal virtual {}
function deployFunds(uint256 _amount) external virtual onlySelf {
_deployFunds(_amount);
}
function freeFunds(uint256 _amount) external virtual onlySelf {
_freeFunds(_amount);
}
function harvestAndReport() external virtual onlySelf returns (uint256) {
return _harvestAndReport();
}
function tendThis(uint256 _totalIdle) external virtual onlySelf {
_tend(_totalIdle);
}
function shutdownWithdraw(uint256 _amount) external virtual onlySelf {
_emergencyWithdraw(_amount);
}
function _delegateCall(
bytes memory _calldata
) internal returns (bytes memory) {
(bool success, bytes memory result) = tokenizedStrategyAddress
.delegatecall(_calldata);
if (!success) {
assembly {
let ptr := mload(0x40)
let size := returndatasize()
returndatacopy(ptr, 0, size)
revert(ptr, size)
}
}
return result;
}
fallback() external {
address _tokenizedStrategyAddress = tokenizedStrategyAddress;
assembly {
calldatacopy(0, 0, calldatasize())
let result := delegatecall(
gas(),
_tokenizedStrategyAddress,
0,
calldatasize(),
0,
0
)
returndatacopy(0, 0, returndatasize())
switch result
case 0 {
revert(0, returndatasize())
}
default {
return(0, returndatasize())
}
}
}
}
文件 3 的 27：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;
}
function _contextSuffixLength() internal view virtual returns (uint256) {
return 0;
}
}
文件 4 的 27：ERC20.sol
pragma solidity ^0.8.0;
import "./IERC20.sol";
import "./extensions/IERC20Metadata.sol";
import "../../utils/Context.sol";
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
constructor(string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
}
function name() public view virtual override returns (string memory) {
return _name;
}
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
function decimals() public view virtual override returns (uint8) {
return 18;
}
function totalSupply() public view virtual override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view virtual override returns (uint256) {
return _balances[account];
}
function transfer(address to, uint256 amount) public virtual override returns (bool) {
address owner = _msgSender();
_transfer(owner, to, amount);
return true;
}
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) {
address owner = _msgSender();
_approve(owner, spender, amount);
return true;
}
function transferFrom(address from, address to, uint256 amount) public virtual override returns (bool) {
address spender = _msgSender();
_spendAllowance(from, spender, amount);
_transfer(from, to, amount);
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
address owner = _msgSender();
_approve(owner, spender, allowance(owner, spender) + addedValue);
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
address owner = _msgSender();
uint256 currentAllowance = allowance(owner, spender);
require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
unchecked {
_approve(owner, spender, currentAllowance - subtractedValue);
}
return true;
}
function _transfer(address from, address to, uint256 amount) internal virtual {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(from, to, amount);
uint256 fromBalance = _balances[from];
require(fromBalance >= amount, "ERC20: transfer amount exceeds balance");
unchecked {
_balances[from] = fromBalance - amount;
_balances[to] += amount;
}
emit Transfer(from, to, amount);
_afterTokenTransfer(from, to, amount);
}
function _mint(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(0), account, amount);
_totalSupply += amount;
unchecked {
_balances[account] += amount;
}
emit Transfer(address(0), account, amount);
_afterTokenTransfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
uint256 accountBalance = _balances[account];
require(accountBalance >= amount, "ERC20: burn amount exceeds balance");
unchecked {
_balances[account] = accountBalance - amount;
_totalSupply -= amount;
}
emit Transfer(account, address(0), amount);
_afterTokenTransfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _spendAllowance(address owner, address spender, uint256 amount) internal virtual {
uint256 currentAllowance = allowance(owner, spender);
if (currentAllowance != type(uint256).max) {
require(currentAllowance >= amount, "ERC20: insufficient allowance");
unchecked {
_approve(owner, spender, currentAllowance - amount);
}
}
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual {}
function _afterTokenTransfer(address from, address to, uint256 amount) internal virtual {}
}
文件 5 的 27：IAsset.sol
pragma solidity >=0.7.0 <0.9.0;
interface IAsset {
}
文件 6 的 27：IAuthentication.sol
pragma solidity >=0.7.0 <0.9.0;
interface IAuthentication {
function getActionId(bytes4 selector) external view returns (bytes32);
}
文件 7 的 27：IAuthorizer.sol
pragma solidity >=0.7.0 <0.9.0;
interface IAuthorizer {
function canPerform(
bytes32 actionId,
address account,
address where
) external view returns (bool);
}
文件 8 的 27：IBaseRewardPool.sol
pragma solidity ^0.8.25;
interface IBaseRewardPool {
event Approval(address indexed owner, address indexed spender, uint256 value);
event Deposit(address indexed caller, address indexed owner, uint256 assets, uint256 shares);
event RewardAdded(uint256 reward);
event RewardPaid(address indexed user, uint256 reward);
event Staked(address indexed user, uint256 amount);
event Transfer(address indexed from, address indexed to, uint256 value);
event Withdraw(
address indexed caller, address indexed receiver, address indexed owner, uint256 assets, uint256 shares
);
event Withdrawn(address indexed user, uint256 amount);
function addExtraReward(address _reward) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function asset() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function clearExtraRewards() external;
function convertToAssets(uint256 shares) external view returns (uint256);
function convertToShares(uint256 assets) external view returns (uint256);
function currentRewards() external view returns (uint256);
function decimals() external view returns (uint8);
function deposit(uint256 assets, address receiver) external returns (uint256);
function duration() external view returns (uint256);
function earned(address account) external view returns (uint256);
function extraRewards(uint256) external view returns (address);
function extraRewardsLength() external view returns (uint256);
function getReward() external returns (bool);
function getReward(address _account, bool _claimExtras) external returns (bool);
function historicalRewards() external view returns (uint256);
function lastTimeRewardApplicable() external view returns (uint256);
function lastUpdateTime() external view returns (uint256);
function maxDeposit(address) external view returns (uint256);
function maxMint(address owner) external view returns (uint256);
function maxRedeem(address owner) external view returns (uint256);
function maxWithdraw(address owner) external view returns (uint256);
function mint(uint256 shares, address receiver) external returns (uint256);
function name() external view returns (string memory);
function newRewardRatio() external view returns (uint256);
function operator() external view returns (address);
function periodFinish() external view returns (uint256);
function pid() external view returns (uint256);
function previewDeposit(uint256 assets) external view returns (uint256);
function previewMint(uint256 shares) external view returns (uint256);
function previewRedeem(uint256 shares) external view returns (uint256);
function previewWithdraw(uint256 assets) external view returns (uint256 shares);
function processIdleRewards() external;
function queueNewRewards(uint256 _rewards) external returns (bool);
function queuedRewards() external view returns (uint256);
function redeem(uint256 shares, address receiver, address owner) external returns (uint256);
function rewardManager() external view returns (address);
function rewardPerToken() external view returns (uint256);
function rewardPerTokenStored() external view returns (uint256);
function rewardRate() external view returns (uint256);
function rewardToken() external view returns (address);
function rewards(address) external view returns (uint256);
function stake(uint256 _amount) external returns (bool);
function stakeAll() external returns (bool);
function stakeFor(address _for, uint256 _amount) external returns (bool);
function stakingToken() external view returns (address);
function symbol() external view returns (string memory);
function totalAssets() external view returns (uint256);
function totalSupply() external view returns (uint256);
function transfer(address, uint256) external returns (bool);
function transferFrom(address, address, uint256) external returns (bool);
function userRewardPerTokenPaid(address) external view returns (uint256);
function withdraw(uint256 amount, bool claim) external returns (bool);
function withdraw(uint256 assets, address receiver, address owner) external returns (uint256);
function withdrawAll(bool claim) external;
function withdrawAllAndUnwrap(bool claim) external;
function withdrawAndUnwrap(uint256 amount, bool claim) external returns (bool);
}
文件 9 的 27：IChainlink.sol
pragma solidity ^0.8.25;
interface IChainlink {
function latestRoundData()
external
view
returns (uint80 roundId, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound);
}
文件 10 的 27：ICurveStablePool.sol
pragma solidity ^0.8.25;
interface ICurveStablePool {
function exchange(int128 i, int128 j, uint256 dx, uint256 minDy) external returns (uint256);
function ma_last_time() external view returns (uint256);
function price_oracle() external view returns (uint256);
}
文件 11 的 27：IERC20.sol
pragma solidity >=0.7.0 <0.9.0;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, 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 sender,
address recipient,
uint256 amount
) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
文件 12 的 27：IERC20Metadata.sol
pragma solidity ^0.8.0;
import "../IERC20.sol";
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
文件 13 的 27：IERC20Permit.sol
pragma solidity ^0.8.0;
interface IERC20Permit {
function permit(
address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) external;
function nonces(address owner) external view returns (uint256);
function DOMAIN_SEPARATOR() external view returns (bytes32);
}
文件 14 的 27：IERC4626.sol
pragma solidity ^0.8.0;
import "../token/ERC20/IERC20.sol";
import "../token/ERC20/extensions/IERC20Metadata.sol";
interface IERC4626 is IERC20, IERC20Metadata {
event Deposit(address indexed sender, address indexed owner, uint256 assets, uint256 shares);
event Withdraw(
address indexed sender,
address indexed receiver,
address indexed owner,
uint256 assets,
uint256 shares
);
function asset() external view returns (address assetTokenAddress);
function totalAssets() external view returns (uint256 totalManagedAssets);
function convertToShares(uint256 assets) external view returns (uint256 shares);
function convertToAssets(uint256 shares) external view returns (uint256 assets);
function maxDeposit(address receiver) external view returns (uint256 maxAssets);
function previewDeposit(uint256 assets) external view returns (uint256 shares);
function deposit(uint256 assets, address receiver) external returns (uint256 shares);
function maxMint(address receiver) external view returns (uint256 maxShares);
function previewMint(uint256 shares) external view returns (uint256 assets);
function mint(uint256 shares, address receiver) external returns (uint256 assets);
function maxWithdraw(address owner) external view returns (uint256 maxAssets);
function previewWithdraw(uint256 assets) external view returns (uint256 shares);
function withdraw(uint256 assets, address receiver, address owner) external returns (uint256 shares);
function maxRedeem(address owner) external view returns (uint256 maxShares);
function previewRedeem(uint256 shares) external view returns (uint256 assets);
function redeem(uint256 shares, address receiver, address owner) external returns (uint256 assets);
}
文件 15 的 27：IFlashLoanRecipient.sol
pragma solidity >=0.7.0 <0.9.0;
import "../solidity-utils/openzeppelin/IERC20.sol";
interface IFlashLoanRecipient {
function receiveFlashLoan(
IERC20[] memory tokens,
uint256[] memory amounts,
uint256[] memory feeAmounts,
bytes memory userData
) external;
}
文件 16 的 27：IProtocolFeesCollector.sol
pragma solidity >=0.7.0 <0.9.0;
pragma experimental ABIEncoderV2;
import "../solidity-utils/openzeppelin/IERC20.sol";
import "./IVault.sol";
import "./IAuthorizer.sol";
interface IProtocolFeesCollector {
event SwapFeePercentageChanged(uint256 newSwapFeePercentage);
event FlashLoanFeePercentageChanged(uint256 newFlashLoanFeePercentage);
function withdrawCollectedFees(
IERC20[] calldata tokens,
uint256[] calldata amounts,
address recipient
) external;
function setSwapFeePercentage(uint256 newSwapFeePercentage) external;
function setFlashLoanFeePercentage(uint256 newFlashLoanFeePercentage) external;
function getSwapFeePercentage() external view returns (uint256);
function getFlashLoanFeePercentage() external view returns (uint256);
function getCollectedFeeAmounts(IERC20[] memory tokens) external view returns (uint256[] memory feeAmounts);
function getAuthorizer() external view returns (IAuthorizer);
function vault() external view returns (IVault);
}
文件 17 的 27：ISignaturesValidator.sol
pragma solidity >=0.7.0 <0.9.0;
interface ISignaturesValidator {
function getDomainSeparator() external view returns (bytes32);
function getNextNonce(address user) external view returns (uint256);
}
文件 18 的 27：IStYeth.sol
pragma solidity ^0.8.25;
interface IStYeth {
function approve(address _spender, uint256 _amount) external returns (bool);
function balanceOf(address _account) external view returns (uint256);
function deposit(uint256 _assets) external returns (uint256);
}
文件 19 的 27：ITemporarilyPausable.sol
pragma solidity >=0.7.0 <0.9.0;
interface ITemporarilyPausable {
event PausedStateChanged(bool paused);
function getPausedState()
external
view
returns (
bool paused,
uint256 pauseWindowEndTime,
uint256 bufferPeriodEndTime
);
}
文件 20 的 27：ITokenizedStrategy.sol
pragma solidity >=0.8.18;
import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import {IERC4626} from "@openzeppelin/contracts/interfaces/IERC4626.sol";
import {IERC20Permit} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Permit.sol";
interface ITokenizedStrategy is IERC4626, IERC20Permit {
event StrategyShutdown();
event NewTokenizedStrategy(
address indexed strategy,
address indexed asset,
string apiVersion
);
event Reported(
uint256 profit,
uint256 loss,
uint256 protocolFees,
uint256 performanceFees
);
event UpdatePerformanceFeeRecipient(
address indexed newPerformanceFeeRecipient
);
event UpdateKeeper(address indexed newKeeper);
event UpdatePerformanceFee(uint16 newPerformanceFee);
event UpdateManagement(address indexed newManagement);
event UpdateEmergencyAdmin(address indexed newEmergencyAdmin);
event UpdateProfitMaxUnlockTime(uint256 newProfitMaxUnlockTime);
event UpdatePendingManagement(address indexed newPendingManagement);
function initialize(
address _asset,
string memory _name,
address _management,
address _performanceFeeRecipient,
address _keeper
) external;
function withdraw(
uint256 assets,
address receiver,
address owner,
uint256 maxLoss
) external returns (uint256);
function redeem(
uint256 shares,
address receiver,
address owner,
uint256 maxLoss
) external returns (uint256);
function requireManagement(address _sender) external view;
function requireKeeperOrManagement(address _sender) external view;
function requireEmergencyAuthorized(address _sender) external view;
function tend() external;
function report() external returns (uint256 _profit, uint256 _loss);
function MAX_FEE() external view returns (uint16);
function FACTORY() external view returns (address);
function apiVersion() external view returns (string memory);
function pricePerShare() external view returns (uint256);
function management() external view returns (address);
function pendingManagement() external view returns (address);
function keeper() external view returns (address);
function emergencyAdmin() external view returns (address);
function performanceFee() external view returns (uint16);
function performanceFeeRecipient() external view returns (address);
function fullProfitUnlockDate() external view returns (uint256);
function profitUnlockingRate() external view returns (uint256);
function profitMaxUnlockTime() external view returns (uint256);
function lastReport() external view returns (uint256);
function isShutdown() external view returns (bool);
function unlockedShares() external view returns (uint256);
function setPendingManagement(address) external;
function acceptManagement() external;
function setKeeper(address _keeper) external;
function setEmergencyAdmin(address _emergencyAdmin) external;
function setPerformanceFee(uint16 _performanceFee) external;
function setPerformanceFeeRecipient(
address _performanceFeeRecipient
) external;
function setProfitMaxUnlockTime(uint256 _profitMaxUnlockTime) external;
function shutdownStrategy() external;
function emergencyWithdraw(uint256 _amount) external;
}
文件 21 的 27：IVault.sol
pragma experimental ABIEncoderV2;
import "../solidity-utils/openzeppelin/IERC20.sol";
import "../solidity-utils/helpers/IAuthentication.sol";
import "../solidity-utils/helpers/ISignaturesValidator.sol";
import "../solidity-utils/helpers/ITemporarilyPausable.sol";
import "../solidity-utils/misc/IWETH.sol";
import "./IAsset.sol";
import "./IAuthorizer.sol";
import "./IFlashLoanRecipient.sol";
import "./IProtocolFeesCollector.sol";
pragma solidity >=0.7.0 <0.9.0;
interface IVault is ISignaturesValidator, ITemporarilyPausable, IAuthentication {
function getAuthorizer() external view returns (IAuthorizer);
function setAuthorizer(IAuthorizer newAuthorizer) external;
event AuthorizerChanged(IAuthorizer indexed newAuthorizer);
function hasApprovedRelayer(address user, address relayer) external view returns (bool);
function setRelayerApproval(
address sender,
address relayer,
bool approved
) external;
event RelayerApprovalChanged(address indexed relayer, address indexed sender, bool approved);
function getInternalBalance(address user, IERC20[] memory tokens) external view returns (uint256[] memory);
function manageUserBalance(UserBalanceOp[] memory ops) external payable;
struct UserBalanceOp {
UserBalanceOpKind kind;
IAsset asset;
uint256 amount;
address sender;
address payable recipient;
}
enum UserBalanceOpKind { DEPOSIT_INTERNAL, WITHDRAW_INTERNAL, TRANSFER_INTERNAL, TRANSFER_EXTERNAL }
event InternalBalanceChanged(address indexed user, IERC20 indexed token, int256 delta);
event ExternalBalanceTransfer(IERC20 indexed token, address indexed sender, address recipient, uint256 amount);
enum PoolSpecialization { GENERAL, MINIMAL_SWAP_INFO, TWO_TOKEN }
function registerPool(PoolSpecialization specialization) external returns (bytes32);
event PoolRegistered(bytes32 indexed poolId, address indexed poolAddress, PoolSpecialization specialization);
function getPool(bytes32 poolId) external view returns (address, PoolSpecialization);
function registerTokens(
bytes32 poolId,
IERC20[] memory tokens,
address[] memory assetManagers
) external;
event TokensRegistered(bytes32 indexed poolId, IERC20[] tokens, address[] assetManagers);
function deregisterTokens(bytes32 poolId, IERC20[] memory tokens) external;
event TokensDeregistered(bytes32 indexed poolId, IERC20[] tokens);
function getPoolTokenInfo(bytes32 poolId, IERC20 token)
external
view
returns (
uint256 cash,
uint256 managed,
uint256 lastChangeBlock,
address assetManager
);
function getPoolTokens(bytes32 poolId)
external
view
returns (
IERC20[] memory tokens,
uint256[] memory balances,
uint256 lastChangeBlock
);
function joinPool(
bytes32 poolId,
address sender,
address recipient,
JoinPoolRequest memory request
) external payable;
struct JoinPoolRequest {
IAsset[] assets;
uint256[] maxAmountsIn;
bytes userData;
bool fromInternalBalance;
}
function exitPool(
bytes32 poolId,
address sender,
address payable recipient,
ExitPoolRequest memory request
) external;
struct ExitPoolRequest {
IAsset[] assets;
uint256[] minAmountsOut;
bytes userData;
bool toInternalBalance;
}
event PoolBalanceChanged(
bytes32 indexed poolId,
address indexed liquidityProvider,
IERC20[] tokens,
int256[] deltas,
uint256[] protocolFeeAmounts
);
enum PoolBalanceChangeKind { JOIN, EXIT }
enum SwapKind { GIVEN_IN, GIVEN_OUT }
function swap(
SingleSwap memory singleSwap,
FundManagement memory funds,
uint256 limit,
uint256 deadline
) external payable returns (uint256);
struct SingleSwap {
bytes32 poolId;
SwapKind kind;
IAsset assetIn;
IAsset assetOut;
uint256 amount;
bytes userData;
}
function batchSwap(
SwapKind kind,
BatchSwapStep[] memory swaps,
IAsset[] memory assets,
FundManagement memory funds,
int256[] memory limits,
uint256 deadline
) external payable returns (int256[] memory);
struct BatchSwapStep {
bytes32 poolId;
uint256 assetInIndex;
uint256 assetOutIndex;
uint256 amount;
bytes userData;
}
event Swap(
bytes32 indexed poolId,
IERC20 indexed tokenIn,
IERC20 indexed tokenOut,
uint256 amountIn,
uint256 amountOut
);
struct FundManagement {
address sender;
bool fromInternalBalance;
address payable recipient;
bool toInternalBalance;
}
function queryBatchSwap(
SwapKind kind,
BatchSwapStep[] memory swaps,
IAsset[] memory assets,
FundManagement memory funds
) external returns (int256[] memory assetDeltas);
function flashLoan(
IFlashLoanRecipient recipient,
IERC20[] memory tokens,
uint256[] memory amounts,
bytes memory userData
) external;
event FlashLoan(IFlashLoanRecipient indexed recipient, IERC20 indexed token, uint256 amount, uint256 feeAmount);
function managePoolBalance(PoolBalanceOp[] memory ops) external;
struct PoolBalanceOp {
PoolBalanceOpKind kind;
bytes32 poolId;
IERC20 token;
uint256 amount;
}
enum PoolBalanceOpKind { WITHDRAW, DEPOSIT, UPDATE }
event PoolBalanceManaged(
bytes32 indexed poolId,
address indexed assetManager,
IERC20 indexed token,
int256 cashDelta,
int256 managedDelta
);
function getProtocolFeesCollector() external view returns (IProtocolFeesCollector);
function setPaused(bool paused) external;
function WETH() external view returns (IWETH);
}
文件 22 的 27：IWETH.sol
pragma solidity >=0.7.0 <0.9.0;
import "../openzeppelin/IERC20.sol";
interface IWETH is IERC20 {
function deposit() external payable;
function withdraw(uint256 amount) external;
}
文件 23 的 27：IWeightedOraclePool.sol
pragma solidity ^0.8.25;
interface IWeightedOraclePool {
struct OracleAverageQuery {
uint8 variable;
uint256 secs;
uint256 ago;
}
function getTimeWeightedAverage(OracleAverageQuery[] memory queries)
external
view
returns (uint256[] memory results);
}
文件 24 的 27：Math.sol
pragma solidity ^0.8.0;
library Math {
enum Rounding {
Down,
Up,
Zero
}
function max(uint256 a, uint256 b) internal pure returns (uint256) {
return a > b ? a : b;
}
function min(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
function average(uint256 a, uint256 b) internal pure returns (uint256) {
return (a & b) + (a ^ b) / 2;
}
function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
return a == 0 ? 0 : (a - 1) / b + 1;
}
function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) {
unchecked {
uint256 prod0;
uint256 prod1;
assembly {
let mm := mulmod(x, y, not(0))
prod0 := mul(x, y)
prod1 := sub(sub(mm, prod0), lt(mm, prod0))
}
if (prod1 == 0) {
return prod0 / denominator;
}
require(denominator > prod1, "Math: mulDiv overflow");
uint256 remainder;
assembly {
remainder := mulmod(x, y, denominator)
prod1 := sub(prod1, gt(remainder, prod0))
prod0 := sub(prod0, remainder)
}
uint256 twos = denominator & (~denominator + 1);
assembly {
denominator := div(denominator, twos)
prod0 := div(prod0, twos)
twos := add(div(sub(0, twos), twos), 1)
}
prod0 |= prod1 * twos;
uint256 inverse = (3 * denominator) ^ 2;
inverse *= 2 - denominator * inverse;
inverse *= 2 - denominator * inverse;
inverse *= 2 - denominator * inverse;
inverse *= 2 - denominator * inverse;
inverse *= 2 - denominator * inverse;
inverse *= 2 - denominator * inverse;
result = prod0 * inverse;
return result;
}
}
function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) {
uint256 result = mulDiv(x, y, denominator);
if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) {
result += 1;
}
return result;
}
function sqrt(uint256 a) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 result = 1 << (log2(a) >> 1);
unchecked {
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
return min(result, a / result);
}
}
function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = sqrt(a);
return result + (rounding == Rounding.Up && result * result < a ? 1 : 0);
}
}
function log2(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
unchecked {
if (value >> 128 > 0) {
value >>= 128;
result += 128;
}
if (value >> 64 > 0) {
value >>= 64;
result += 64;
}
if (value >> 32 > 0) {
value >>= 32;
result += 32;
}
if (value >> 16 > 0) {
value >>= 16;
result += 16;
}
if (value >> 8 > 0) {
value >>= 8;
result += 8;
}
if (value >> 4 > 0) {
value >>= 4;
result += 4;
}
if (value >> 2 > 0) {
value >>= 2;
result += 2;
}
if (value >> 1 > 0) {
result += 1;
}
}
return result;
}
function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = log2(value);
return result + (rounding == Rounding.Up && 1 << result < value ? 1 : 0);
}
}
function log10(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
unchecked {
if (value >= 10 ** 64) {
value /= 10 ** 64;
result += 64;
}
if (value >= 10 ** 32) {
value /= 10 ** 32;
result += 32;
}
if (value >= 10 ** 16) {
value /= 10 ** 16;
result += 16;
}
if (value >= 10 ** 8) {
value /= 10 ** 8;
result += 8;
}
if (value >= 10 ** 4) {
value /= 10 ** 4;
result += 4;
}
if (value >= 10 ** 2) {
value /= 10 ** 2;
result += 2;
}
if (value >= 10 ** 1) {
result += 1;
}
}
return result;
}
function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = log10(value);
return result + (rounding == Rounding.Up && 10 ** result < value ? 1 : 0);
}
}
function log256(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
unchecked {
if (value >> 128 > 0) {
value >>= 128;
result += 16;
}
if (value >> 64 > 0) {
value >>= 64;
result += 8;
}
if (value >> 32 > 0) {
value >>= 32;
result += 4;
}
if (value >> 16 > 0) {
value >>= 16;
result += 2;
}
if (value >> 8 > 0) {
result += 1;
}
}
return result;
}
function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = log256(value);
return result + (rounding == Rounding.Up && 1 << (result << 3) < value ? 1 : 0);
}
}
}
文件 25 的 27：SafeERC20.sol
pragma solidity ^0.8.0;
import "../IERC20.sol";
import "../extensions/IERC20Permit.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 oldAllowance = token.allowance(address(this), spender);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, oldAllowance + value));
}
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");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, oldAllowance - value));
}
}
function forceApprove(IERC20 token, address spender, uint256 value) internal {
bytes memory approvalCall = abi.encodeWithSelector(token.approve.selector, spender, value);
if (!_callOptionalReturnBool(token, approvalCall)) {
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, 0));
_callOptionalReturn(token, approvalCall);
}
}
function safePermit(
IERC20Permit token,
address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) internal {
uint256 nonceBefore = token.nonces(owner);
token.permit(owner, spender, value, deadline, v, r, s);
uint256 nonceAfter = token.nonces(owner);
require(nonceAfter == nonceBefore + 1, "SafeERC20: permit did not succeed");
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
require(returndata.length == 0 || abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
function _callOptionalReturnBool(IERC20 token, bytes memory data) private returns (bool) {
(bool success, bytes memory returndata) = address(token).call(data);
return
success && (returndata.length == 0 || abi.decode(returndata, (bool))) && Address.isContract(address(token));
}
}
文件 26 的 27：Strategy.sol
pragma solidity ^0.8.18;
import {BaseStrategy, ERC20} from "@tokenized-strategy/BaseStrategy.sol";
import {SafeERC20, IERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import {Math} from "@openzeppelin/contracts/utils/math/Math.sol";
import {IVault} from "@balancer/interfaces/contracts/vault/IVault.sol";
import {WeightedPoolUserData} from "@balancer/interfaces/contracts/pool-weighted/WeightedPoolUserData.sol";
import {IAsset} from "@balancer/interfaces/contracts/vault/IAsset.sol";
import {IBaseRewardPool} from "../src/interfaces/aura/IBaseRewardPool.sol";
import {IStYeth} from "../src/interfaces/yearn/IStYeth.sol";
import {ICurveStablePool} from "../src/interfaces/curve/ICurveStablePool.sol";
import {IChainlink} from "../src/interfaces/chainlink/IChainlink.sol";
import {IWeightedOraclePool} from "../src/interfaces/balancer/IWeightedOraclePool.sol";
contract GoldenBoyzCompounderStrategy is BaseStrategy {
using SafeERC20 for IERC20;
uint256 constant BPS = 10_000;
IERC20 constant AURA = IERC20(0xC0c293ce456fF0ED870ADd98a0828Dd4d2903DBF);
IERC20 constant BAL = IERC20(0xba100000625a3754423978a60c9317c58a424e3D);
IERC20 constant WETH = IERC20(0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2);
IERC20 constant YETH = IERC20(0x1BED97CBC3c24A4fb5C069C6E311a967386131f7);
address constant GOLD = 0x9DeB0fc809955b79c85e82918E8586d3b7d2695a;
IVault constant BALANCER_VAULT = IVault(0xBA12222222228d8Ba445958a75a0704d566BF2C8);
IStYeth constant ST_YETH = IStYeth(0x583019fF0f430721aDa9cfb4fac8F06cA104d0B4);
ICurveStablePool constant YETH_CURVE_POOL = ICurveStablePool(0x69ACcb968B19a53790f43e57558F5E443A91aF22);
IWeightedOraclePool constant ORACLE_WEIGHTED_POOL = IWeightedOraclePool(0xc29562b045D80fD77c69Bec09541F5c16fe20d9d);
IChainlink constant BAL_ETH_FEED = IChainlink(0xC1438AA3823A6Ba0C159CfA8D98dF5A994bA120b);
IBaseRewardPool public immutable rewardsContract;
uint256 public slippBalToWeth;
uint256 public slippAuraToWeth;
uint256 public slippWethToYeth;
uint256 public oracleWeightedPoolTimeWindow;
event SlippBalToWethUpdated(uint256 oldValue, uint256 currentValue);
event SlippAuraToWethUpdated(uint256 oldValue, uint256 currentValue);
event SlippWethToYethUpdated(uint256 oldValue, uint256 currentValue);
event OracleWeightedPoolTimeWindowUpdated(uint256 oldValue, uint256 currentValue);
constructor(address _asset, address _rewardsContract) BaseStrategy(_asset, "GoldenBoyzCompounderStrategy") {
asset.approve(_rewardsContract, type(uint256).max);
rewardsContract = IBaseRewardPool(_rewardsContract);
if (rewardsContract.asset() != _asset) revert("Invalid rewards contract");
slippBalToWeth = 9_800;
slippAuraToWeth = 9_800;
slippWethToYeth = 9_970;
oracleWeightedPoolTimeWindow = 1 hours;
BAL.approve(address(BALANCER_VAULT), type(uint256).max);
AURA.approve(address(BALANCER_VAULT), type(uint256).max);
ST_YETH.approve(address(BALANCER_VAULT), type(uint256).max);
WETH.approve(address(YETH_CURVE_POOL), type(uint256).max);
YETH.approve(address(ST_YETH), type(uint256).max);
}
function setSlippBalToWeth(uint256 _slippBalToWeth) external onlyManagement {
if (_slippBalToWeth > 9_900 || _slippBalToWeth < 9_600) revert("Slippage out of bounds");
uint256 oldSlippBalToWeth = slippBalToWeth;
slippBalToWeth = _slippBalToWeth;
emit SlippBalToWethUpdated(oldSlippBalToWeth, slippBalToWeth);
}
function setSlippAuraToWeth(uint256 _slippAuraToWeth) external onlyManagement {
if (_slippAuraToWeth > 9_900 || _slippAuraToWeth < 9_600) revert("Slippage out of bounds");
uint256 oldSlippAuraToWeth = slippAuraToWeth;
slippAuraToWeth = _slippAuraToWeth;
emit SlippAuraToWethUpdated(oldSlippAuraToWeth, slippAuraToWeth);
}
function setSlippWethToYeth(uint256 _slippWethToYeth) external onlyManagement {
if (_slippWethToYeth > 9_970 || _slippWethToYeth < 9_900) revert("Slippage out of bounds");
uint256 oldSlippWethToYeth = slippWethToYeth;
slippWethToYeth = _slippWethToYeth;
emit SlippWethToYethUpdated(oldSlippWethToYeth, slippWethToYeth);
}
function setOracleWeightedPoolTimeWindow(uint256 _oracleWeightedPoolTimeWindow) external onlyManagement {
if (_oracleWeightedPoolTimeWindow < 1 hours || _oracleWeightedPoolTimeWindow > 6 hours) {
revert("Time window out of bounds");
}
uint256 oldOracleWeightedPoolTimeWindow = oracleWeightedPoolTimeWindow;
oracleWeightedPoolTimeWindow = _oracleWeightedPoolTimeWindow;
emit OracleWeightedPoolTimeWindowUpdated(oldOracleWeightedPoolTimeWindow, oracleWeightedPoolTimeWindow);
}
function _deployFunds(uint256 _amount) internal override {
rewardsContract.deposit(_amount, address(this));
}
function _freeFunds(uint256 _amount) internal override {
rewardsContract.withdrawAndUnwrap(_amount, false);
}
function _harvestAndReport() internal override returns (uint256 _totalAssets) {
if (!TokenizedStrategy.isShutdown()) {
rewardsContract.getReward();
uint256 balancerB = BAL.balanceOf(address(this));
if (balancerB > 0) {
_balancerToWethSwap(balancerB);
uint256 auraB = AURA.balanceOf(address(this));
if (auraB > 0) {
_auraToWethSwap(auraB);
}
uint256 wethB = WETH.balanceOf(address(this));
if (wethB > 0) {
_wethToYethSwap(wethB);
}
uint256 yethB = YETH.balanceOf(address(this));
if (yethB > 0) {
_stakeYeth(yethB);
_singleSidedYethDepositBpt(ST_YETH.balanceOf(address(this)));
_deployFunds(asset.balanceOf(address(this)));
}
}
}
_totalAssets = asset.balanceOf(address(this)) + rewardsContract.balanceOf(address(this));
}
function _emergencyWithdraw(uint256 _amount) internal override {
_amount = Math.min(_amount, rewardsContract.balanceOf(address(this)));
_freeFunds(_amount);
}
function _balToEtHOracleScale(uint256 _balancerAmount) internal view returns (uint256) {
(, int256 answer,, uint256 ts,) = BAL_ETH_FEED.latestRoundData();
if (answer < 0) revert("Chainlink price is negative");
if (block.timestamp - ts > 24 hours) revert("Chainlink price is outdated");
return uint256(answer) * _balancerAmount / 1e18;
}
function _balancerToWethSwap(uint256 _amount) internal {
BALANCER_VAULT.swap(
IVault.SingleSwap({
poolId: 0x5c6ee304399dbdb9c8ef030ab642b10820db8f56000200000000000000000014,
kind: IVault.SwapKind.GIVEN_IN,
assetIn: IAsset(address(BAL)),
assetOut: IAsset(address(WETH)),
amount: _amount,
userData: ""
}),
IVault.FundManagement({
sender: address(this),
fromInternalBalance: false,
recipient: payable(address(this)),
toInternalBalance: false
}),
_balToEtHOracleScale(_amount) * slippBalToWeth / BPS,
block.timestamp
);
}
function _auraToEthOracleWeightedPoolScale(uint256 _auraAmount) internal view returns (uint256) {
IWeightedOraclePool.OracleAverageQuery[] memory q = new IWeightedOraclePool.OracleAverageQuery[](1);
q[0] = IWeightedOraclePool.OracleAverageQuery({variable: 0, secs: oracleWeightedPoolTimeWindow, ago: 0});
return (_auraAmount * ORACLE_WEIGHTED_POOL.getTimeWeightedAverage(q)[0]) / 1e18;
}
function _auraToWethSwap(uint256 _amount) internal {
BALANCER_VAULT.swap(
IVault.SingleSwap({
poolId: 0xcfca23ca9ca720b6e98e3eb9b6aa0ffc4a5c08b9000200000000000000000274,
kind: IVault.SwapKind.GIVEN_IN,
assetIn: IAsset(address(AURA)),
assetOut: IAsset(address(WETH)),
amount: _amount,
userData: ""
}),
IVault.FundManagement({
sender: address(this),
fromInternalBalance: false,
recipient: payable(address(this)),
toInternalBalance: false
}),
_auraToEthOracleWeightedPoolScale(_amount) * slippAuraToWeth / BPS,
block.timestamp
);
}
function _wethToYethScale(uint256 _wethAmount) internal view returns (uint256) {
return (_wethAmount * 1e18) / YETH_CURVE_POOL.price_oracle();
}
function _wethToYethSwap(uint256 _amount) internal {
YETH_CURVE_POOL.exchange(0, 1, _amount, _wethToYethScale(_amount) * slippWethToYeth / BPS);
}
function _stakeYeth(uint256 _amount) internal {
ST_YETH.deposit(_amount);
}
function _singleSidedYethDepositBpt(uint256 _singleSideYethAmount) internal {
uint256[] memory maxAmountsIn = new uint256[](2);
maxAmountsIn[0] = _singleSideYethAmount;
IAsset[] memory assets = new IAsset[](2);
assets[0] = IAsset(address(ST_YETH));
assets[1] = IAsset(IAsset(GOLD));
IVault.JoinPoolRequest memory joinRequest = IVault.JoinPoolRequest({
assets: assets,
maxAmountsIn: maxAmountsIn,
userData: abi.encode(WeightedPoolUserData.JoinKind.EXACT_TOKENS_IN_FOR_BPT_OUT, maxAmountsIn, 0),
fromInternalBalance: false
});
BALANCER_VAULT.joinPool(
0xcf8dfdb73e7434b05903b5599fb96174555f43530002000000000000000006c3,
address(this),
address(this),
joinRequest
);
}
}
文件 27 的 27：WeightedPoolUserData.sol
pragma solidity >=0.7.0 <0.9.0;
import "../solidity-utils/openzeppelin/IERC20.sol";
library WeightedPoolUserData {
enum JoinKind { INIT, EXACT_TOKENS_IN_FOR_BPT_OUT, TOKEN_IN_FOR_EXACT_BPT_OUT, ALL_TOKENS_IN_FOR_EXACT_BPT_OUT }
enum ExitKind { EXACT_BPT_IN_FOR_ONE_TOKEN_OUT, EXACT_BPT_IN_FOR_TOKENS_OUT, BPT_IN_FOR_EXACT_TOKENS_OUT }
function joinKind(bytes memory self) internal pure returns (JoinKind) {
return abi.decode(self, (JoinKind));
}
function exitKind(bytes memory self) internal pure returns (ExitKind) {
return abi.decode(self, (ExitKind));
}
function initialAmountsIn(bytes memory self) internal pure returns (uint256[] memory amountsIn) {
(, amountsIn) = abi.decode(self, (JoinKind, uint256[]));
}
function exactTokensInForBptOut(bytes memory self)
internal
pure
returns (uint256[] memory amountsIn, uint256 minBPTAmountOut)
{
(, amountsIn, minBPTAmountOut) = abi.decode(self, (JoinKind, uint256[], uint256));
}
function tokenInForExactBptOut(bytes memory self) internal pure returns (uint256 bptAmountOut, uint256 tokenIndex) {
(, bptAmountOut, tokenIndex) = abi.decode(self, (JoinKind, uint256, uint256));
}
function allTokensInForExactBptOut(bytes memory self) internal pure returns (uint256 bptAmountOut) {
(, bptAmountOut) = abi.decode(self, (JoinKind, uint256));
}
function exactBptInForTokenOut(bytes memory self) internal pure returns (uint256 bptAmountIn, uint256 tokenIndex) {
(, bptAmountIn, tokenIndex) = abi.decode(self, (ExitKind, uint256, uint256));
}
function exactBptInForTokensOut(bytes memory self) internal pure returns (uint256 bptAmountIn) {
(, bptAmountIn) = abi.decode(self, (ExitKind, uint256));
}
function bptInForExactTokensOut(bytes memory self)
internal
pure
returns (uint256[] memory amountsOut, uint256 maxBPTAmountIn)
{
(, amountsOut, maxBPTAmountIn) = abi.decode(self, (ExitKind, uint256[], uint256));
}
}
{
"compilationTarget": {
"src/Strategy.sol": "GoldenBoyzCompounderStrategy"
},
"evmVersion": "paris",
"libraries": {},
"metadata": {
"bytecodeHash": "ipfs"
},
"optimizer": {
"enabled": true,
"runs": 200
},
"remappings": [
":@balancer-labs/=lib/balancer/../../node_modules/@balancer-labs/",
":@balancer/=lib/balancer/pkg/",
":@openzeppelin/contracts/=lib/openzeppelin-contracts/contracts/",
":@periphery/=lib/tokenized-strategy-periphery/src/",
":@tokenized-strategy/=lib/tokenized-strategy/src/",
":@yearn-vaults/=lib/tokenized-strategy-periphery/lib/yearn-vaults-v3/contracts/",
":balancer/=lib/balancer/",
":ds-test/=lib/tokenized-strategy-periphery/lib/forge-std/lib/ds-test/src/",
":forge-std/=lib/forge-std/src/",
":openzeppelin-contracts/=lib/openzeppelin-contracts/",
":openzeppelin/=lib/openzeppelin-contracts/contracts/",
":tokenized-strategy-periphery/=lib/tokenized-strategy-periphery/src/",
":tokenized-strategy/=lib/tokenized-strategy/src/"
]
}[{"inputs":[{"internalType":"address","name":"_asset","type":"address"},{"internalType":"address","name":"_rewardsContract","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"oldValue","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"currentValue","type":"uint256"}],"name":"OracleWeightedPoolTimeWindowUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"oldValue","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"currentValue","type":"uint256"}],"name":"SlippAuraToWethUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"oldValue","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"currentValue","type":"uint256"}],"name":"SlippBalToWethUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"oldValue","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"currentValue","type":"uint256"}],"name":"SlippWethToYethUpdated","type":"event"},{"stateMutability":"nonpayable","type":"fallback"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"availableDepositLimit","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"availableWithdrawLimit","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"deployFunds","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"freeFunds","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"harvestAndReport","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"oracleWeightedPoolTimeWindow","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"rewardsContract","outputs":[{"internalType":"contract IBaseRewardPool","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_oracleWeightedPoolTimeWindow","type":"uint256"}],"name":"setOracleWeightedPoolTimeWindow","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_slippAuraToWeth","type":"uint256"}],"name":"setSlippAuraToWeth","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_slippBalToWeth","type":"uint256"}],"name":"setSlippBalToWeth","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_slippWethToYeth","type":"uint256"}],"name":"setSlippWethToYeth","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"shutdownWithdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"slippAuraToWeth","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"slippBalToWeth","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"slippWethToYeth","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_totalIdle","type":"uint256"}],"name":"tendThis","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"tendTrigger","outputs":[{"internalType":"bool","name":"","type":"bool"},{"internalType":"bytes","name":"","type":"bytes"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"tokenizedStrategyAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"}]
