Solidity API
Documentation generated with solidity-docgen
Last updated
Documentation generated with solidity-docgen
Last updated
Basically an ERC20 with minting functionality operated by the "operator" of the VoterProxy (Booster).
The minting schedule is based on the amount of CRV earned through staking and is distirbuted along a supply curve (cliffs etc). Fork of ConvexToken.
address operator
address vecrvProxy
uint256 EMISSIONS_MAX_SUPPLY
uint256 INIT_MINT_AMOUNT
uint256 totalCliffs
uint256 reductionPerCliff
address minter
uint256 minterMinted
event Initialised()
event OperatorChanged(address previousOperator, address newOperator)
constructor(address _proxy, string _nameArg, string _symbolArg) public
_proxy
address
CVX VoterProxy
_nameArg
string
Token name
_symbolArg
string
Token symbol
function init(address _to, address _minter) external
Initialise and mints initial supply of tokens.
_to
address
Target address to mint.
_minter
address
The minter address.
function updateOperator() public
This can be called if the operator of the voterProxy somehow changes.
function mint(address _to, uint256 _amount) external
Mints AURA to a given user based on the BAL supply schedule.
function minterMint(address _to, uint256 _amount) external
Allows minter to mint to a specific address
Modifications from convex-platform/contracts/contracts/BaseRewardPool.sol: - Delayed start (tokens transferred then delay is enforced before notification) - One time duration of 14 days - Remove child reward contracts - Penalty on claim at 20%
contract IERC20 rewardToken
contract IERC20 stakingToken
uint256 duration
address rewardManager
contract IAuraLocker auraLocker
address penaltyForwarder
uint256 pendingPenalty
uint256 startTime
uint256 periodFinish
uint256 rewardRate
uint256 lastUpdateTime
uint256 rewardPerTokenStored
uint256 _totalSupply
mapping(address => uint256) userRewardPerTokenPaid
mapping(address => uint256) rewards
mapping(address => uint256) _balances
event RewardAdded(uint256 reward)
event Staked(address user, uint256 amount)
event Withdrawn(address user, uint256 amount)
event RewardPaid(address user, uint256 reward, bool locked)
event PenaltyForwarded(uint256 amount)
event Rescued()
constructor(address _stakingToken, address _rewardToken, address _rewardManager, address _auraLocker, address _penaltyForwarder, uint256 _startDelay) public
Simple constructor
_stakingToken
address
Pool LP token
_rewardToken
address
$AURA
_rewardManager
address
Depositor
_auraLocker
address
$AURA lock contract
_penaltyForwarder
address
Address to which penalties are sent
_startDelay
uint256
function totalSupply() public view returns (uint256)
function balanceOf(address account) public view returns (uint256)
modifier updateReward(address account)
function lastTimeRewardApplicable() public view returns (uint256)
function rewardPerToken() public view returns (uint256)
function earned(address account) public view returns (uint256)
function stake(uint256 _amount) public returns (bool)
function stakeAll() external returns (bool)
function stakeFor(address _for, uint256 _amount) public returns (bool)
function withdraw(uint256 amount, bool claim, bool lock) public returns (bool)
function getReward(bool _lock) public returns (bool)
Gives a staker their rewards
_lock
bool
Lock the rewards? If false, takes a 20% haircut
function forwardPenalty() public
Forwards to the penalty forwarder for distro to Aura Lockers
function rescueReward() public
Rescues the reward token provided it hasn't been initiated yet
function setLocker(address _newLocker) external
Updates the locker address
function initialiseRewards() external returns (bool)
Called once to initialise the rewards based on balance of stakeToken
Claim zap to bundle various reward claims
Claims from all pools, and stakes cvxCrv and CVX if wanted. v2: - change exchange to use curve pool - add getReward(address,token) type - add option to lock cvx - add option use all funds in wallet
address crv
address cvx
address cvxCrv
address crvDepositWrapper
address cvxCrvRewards
address locker
address owner
enum Options {
ClaimCvxCrv,
ClaimLockedCvx,
ClaimLockedCvxStake,
LockCrvDeposit,
UseAllWalletFunds,
LockCvx
}
constructor(address _crv, address _cvx, address _cvxCrv, address _crvDepositWrapper, address _cvxCrvRewards, address _locker) public
_crv
address
CRV token (0xD533a949740bb3306d119CC777fa900bA034cd52);
_cvx
address
CVX token (0x4e3FBD56CD56c3e72c1403e103b45Db9da5B9D2B);
_cvxCrv
address
cvxCRV token (0x62B9c7356A2Dc64a1969e19C23e4f579F9810Aa7);
_crvDepositWrapper
address
crvDepositWrapper (0x8014595F2AB54cD7c604B00E9fb932176fDc86Ae);
_cvxCrvRewards
address
cvxCrvRewards (0x3Fe65692bfCD0e6CF84cB1E7d24108E434A7587e);
_locker
address
vlCVX (0xD18140b4B819b895A3dba5442F959fA44994AF50);
function getName() external pure returns (string)
function setApprovals() external
Approve spending of: crv -> crvDepositor cvxCrv -> cvxCrvRewards cvx -> Locker
function _checkOption(uint256 _mask, uint256 _flag) internal pure returns (bool)
Use bitmask to check if option flag is set
function claimRewards(address[] rewardContracts, address[] extraRewardContracts, address[] tokenRewardContracts, address[] tokenRewardTokens, uint256 depositCrvMaxAmount, uint256 minAmountOut, uint256 depositCvxMaxAmount, uint256 options) external
Claim all the rewards
rewardContracts
address[]
Array of addresses for LP token rewards
extraRewardContracts
address[]
Array of addresses for extra rewards
tokenRewardContracts
address[]
Array of addresses for token rewards e.g vlCvxExtraRewardDistribution
tokenRewardTokens
address[]
Array of token reward addresses to use with tokenRewardContracts
depositCrvMaxAmount
uint256
The max amount of CRV to deposit if converting to crvCvx
minAmountOut
uint256
The min amount out for crv:cvxCrv swaps if swapping. Set this to zero if you want to use CrvDepositor instead of balancer swap
depositCvxMaxAmount
uint256
The max amount of CVX to deposit if locking CVX
options
uint256
Claim options
function _claimExtras(uint256 depositCrvMaxAmount, uint256 minAmountOut, uint256 depositCvxMaxAmount, uint256 removeCrvBalance, uint256 removeCvxBalance, uint256 options) internal
Claim additional rewards from: - cvxCrvRewards - cvxLocker
depositCrvMaxAmount
uint256
see claimRewards
minAmountOut
uint256
see claimRewards
depositCvxMaxAmount
uint256
see claimRewards
removeCrvBalance
uint256
crvBalance to ignore and not redeposit (starting Crv balance)
removeCvxBalance
uint256
cvxBalance to ignore and not redeposit (starting Cvx balance)
options
uint256
see claimRewards
Effectively allows for rolling 16 week lockups of CVX, and provides balances available at each epoch (1 week). Also receives cvxCrv from CvxStakingProxy
and redistributes to depositors.
Invdividual and delegatee vote power lookups both use independent accounting mechanisms.
struct RewardData {
uint32 periodFinish;
uint32 lastUpdateTime;
uint96 rewardRate;
uint96 rewardPerTokenStored;
}
struct UserData {
uint128 rewardPerTokenPaid;
uint128 rewards;
}
struct EarnedData {
address token;
uint256 amount;
}
struct Balances {
uint112 locked;
uint32 nextUnlockIndex;
}
struct LockedBalance {
uint112 amount;
uint32 unlockTime;
}
struct Epoch {
uint224 supply;
uint32 date;
}
struct DelegateeCheckpoint {
uint224 votes;
uint32 epochStart;
}
address[] rewardTokens
mapping(address => uint256) queuedRewards
uint256 newRewardRatio
mapping(address => struct AuraLocker.RewardData) rewardData
mapping(address => mapping(address => bool)) rewardDistributors
mapping(address => mapping(address => struct AuraLocker.UserData)) userData
uint256 rewardsDuration
uint256 lockDuration
uint256 lockedSupply
struct AuraLocker.Epoch[] epochs
mapping(address => struct AuraLocker.Balances) balances
mapping(address => struct AuraLocker.LockedBalance[]) userLocks
mapping(address => address) _delegates
mapping(address => struct AuraLocker.DelegateeCheckpoint[]) _checkpointedVotes
mapping(address => mapping(uint256 => uint256)) delegateeUnlocks
mapping(address => bool) blacklist
contract IERC20 stakingToken
address cvxCrv
uint256 denominator
address cvxcrvStaking
uint256 kickRewardPerEpoch
uint256 kickRewardEpochDelay
bool isShutdown
string _name
string _symbol
uint8 _decimals
event DelegateChanged(address delegator, address fromDelegate, address toDelegate)
event DelegateCheckpointed(address delegate)
event Recovered(address _token, uint256 _amount)
event RewardPaid(address _user, address _rewardsToken, uint256 _reward)
event Staked(address _user, uint256 _paidAmount, uint256 _lockedAmount)
event Withdrawn(address _user, uint256 _amount, bool _relocked)
event KickReward(address _user, address _kicked, uint256 _reward)
event RewardAdded(address _token, uint256 _reward)
event BlacklistModified(address account, bool blacklisted)
event KickIncentiveSet(uint256 rate, uint256 delay)
event Shutdown()
constructor(string _nameArg, string _symbolArg, address _stakingToken, address _cvxCrv, address _cvxCrvStaking) public
_nameArg
string
Token name, simples
_symbolArg
string
Token symbol
_stakingToken
address
CVX (0x4e3FBD56CD56c3e72c1403e103b45Db9da5B9D2B)
_cvxCrv
address
cvxCRV (0x62B9c7356A2Dc64a1969e19C23e4f579F9810Aa7)
_cvxCrvStaking
address
cvxCRV rewards (0x3Fe65692bfCD0e6CF84cB1E7d24108E434A7587e)
modifier updateReward(address _account)
modifier notBlacklisted(address _sender, address _receiver)
function modifyBlacklist(address _account, bool _blacklisted) external
function addReward(address _rewardsToken, address _distributor) external
function approveRewardDistributor(address _rewardsToken, address _distributor, bool _approved) external
function setKickIncentive(uint256 _rate, uint256 _delay) external
function shutdown() external
function recoverERC20(address _tokenAddress, uint256 _tokenAmount) external
function setApprovals() external
function lock(address _account, uint256 _amount) external
function _lock(address _account, uint256 _amount) internal
function getReward(address _account) external
function getReward(address _account, bool _stake) public
function getReward(address _account, bool[] _skipIdx) external
function checkpointEpoch() external
function _checkpointEpoch() internal
function processExpiredLocks(bool _relock) external
function kickExpiredLocks(address _account) external
function emergencyWithdraw() external
function _processExpiredLocks(address _account, bool _relock, address _rewardAddress, uint256 _checkDelay) internal
function delegate(address newDelegatee) external virtual
Delegate votes from the sender to newDelegatee
.
function _checkpointDelegate(address _account, uint256 _upcomingAddition, uint256 _upcomingDeduction) internal
function delegates(address account) public view virtual returns (address)
Get the address account
is currently delegating to.
function getVotes(address account) external view returns (uint256)
Gets the current votes balance for account
function checkpoints(address account, uint32 pos) external view virtual returns (struct AuraLocker.DelegateeCheckpoint)
Get the pos
-th checkpoint for account
.
function numCheckpoints(address account) external view virtual returns (uint32)
Get number of checkpoints for account
.
function getPastVotes(address account, uint256 timestamp) public view returns (uint256 votes)
Retrieve the number of votes for account
at the end of blockNumber
.
function getPastTotalSupply(uint256 timestamp) external view returns (uint256)
Retrieve the totalSupply
at the end of timestamp
. Note, this value is the sum of all balances. It is but NOT the sum of all the delegated votes!
function _checkpointsLookup(struct AuraLocker.DelegateeCheckpoint[] ckpts, uint256 epochStart) private view returns (struct AuraLocker.DelegateeCheckpoint)
Lookup a value in a list of (sorted) checkpoints. Copied from oz/ERC20Votes.sol
function balanceOf(address _user) external view returns (uint256 amount)
function balanceAtEpochOf(uint256 _epoch, address _user) public view returns (uint256 amount)
function lockedBalances(address _user) external view returns (uint256 total, uint256 unlockable, uint256 locked, struct AuraLocker.LockedBalance[] lockData)
function totalSupply() external view returns (uint256 supply)
function totalSupplyAtEpoch(uint256 _epoch) public view returns (uint256 supply)
function findEpochId(uint256 _time) public view returns (uint256 epoch)
function epochCount() external view returns (uint256)
function decimals() external view returns (uint8)
function name() external view returns (string)
function symbol() external view returns (string)
function claimableRewards(address _account) external view returns (struct AuraLocker.EarnedData[] userRewards)
function lastTimeRewardApplicable(address _rewardsToken) external view returns (uint256)
function rewardPerToken(address _rewardsToken) external view returns (uint256)
function _earned(address _user, address _rewardsToken, uint256 _balance) internal view returns (uint256)
function _lastTimeRewardApplicable(uint256 _finishTime) internal view returns (uint256)
function _rewardPerToken(address _rewardsToken) internal view returns (uint256)
function queueNewRewards(address _rewardsToken, uint256 _rewards) external
function _notifyReward(address _rewardsToken, uint256 _reward) internal
Forked from convex-platform/contracts/contracts/MerkleAirdrop.sol. Changes: - solc 0.8.11 & OpenZeppelin MerkleDrop - Delayed start w/ trigger - EndTime for withdrawal to treasuryDAO - Penalty on claim & AuraLocker lock (only if address(auraLocker) != 0) - Non custodial (cannot change root)
address dao
bytes32 merkleRoot
contract IERC20 aura
contract IAuraLocker auraLocker
address penaltyForwarder
uint256 pendingPenalty
uint256 deployTime
uint256 startTime
uint256 expiryTime
mapping(address => bool) hasClaimed
event DaoSet(address newDao)
event RootSet(bytes32 newRoot)
event StartedEarly()
event ExpiredWithdrawn(uint256 amount)
event LockerSet(address newLocker)
event Claimed(address addr, uint256 amt, bool locked)
event PenaltyForwarded(uint256 amount)
event Rescued()
constructor(address _dao, bytes32 _merkleRoot, address _aura, address _auraLocker, address _penaltyForwarder, uint256 _startDelay, uint256 _expiresAfter) public
_dao
address
The Aura Dao
_merkleRoot
bytes32
Merkle root
_aura
address
Aura token
_auraLocker
address
Aura locker contract
_penaltyForwarder
address
PenaltyForwarded contract
_startDelay
uint256
Delay until claim is live
_expiresAfter
uint256
Timestamp claim expires
function setDao(address _newDao) external
function setRoot(bytes32 _merkleRoot) external
function startEarly() external
function withdrawExpired() external
function setLocker(address _newLocker) external
function rescueReward() public
function claim(bytes32[] _proof, uint256 _amount, bool _lock) public returns (bool)
function forwardPenalty() public
Wraps the AuraToken minterMint function and protects from inflation until 3 years have passed.
Ownership initially owned by the DAO, but likely transferred to smart contract wrapper or additional value system at some stage as directed by token holders.
contract AuraToken aura
Aura token
uint256 inflationProtectionTime
Timestamp upon which minting will be possible
constructor(address _aura, address _dao) public
function mint(address _to, uint256 _amount) external
Mint function allows the owner of the contract to inflate AURA post protection time
_to
address
Recipient address
_amount
uint256
Amount of tokens
Receives a given token and forwards it on to a distribution contract.
contract IExtraRewardsDistributor distributor
contract IERC20 token
uint256 distributionDelay
uint256 lastDistribution
event Forwarded(uint256 amount)
event DistributorChanged(address newDistributor)
constructor(address _distributor, address _token, uint256 _delay, address _dao) public
During deployment approves the distributor to spend all tokens
_distributor
address
Contract that will distribute tokens
_token
address
Token to be distributed
_delay
uint256
Delay between each distribution trigger
_dao
address
Address of DAO
function forward() public
Forwards the complete balance of token in this contract to the distributor
function setDistributor(address _distributor) public
Updates distributor address
Receives CRV from the Booster as overall reward, then distributes to vlCVX holders. Also acts as a depositor proxy to support deposit/withdrawals from the CVX staking contract.
From CVX: - receive tokens to stake - get current staked balance - withdraw staked tokens - send rewards back to owner(cvx locker) - register token types that can be distributed
address crv
address cvx
address cvxCrv
address keeper
address crvDepositorWrapper
uint256 outputBps
uint256 denominator
address rewards
address owner
address pendingOwner
uint256 callIncentive
event RewardsDistributed(address token, uint256 amount)
event CallIncentiveChanged(uint256 incentive)
constructor(address _rewards, address _crv, address _cvx, address _cvxCrv, address _crvDepositorWrapper, uint256 _outputBps) public
_rewards
address
vlCVX
_crv
address
CRV token
_cvx
address
CVX token
_cvxCrv
address
cvxCRV token
_crvDepositorWrapper
address
Wrapper that converts CRV to CRVBPT and deposits
_outputBps
uint256
Configurable output bps where 100% == 10000
function setCrvDepositorWrapper(address _crvDepositorWrapper, uint256 _outputBps) external
Set CrvDepositorWrapper
_crvDepositorWrapper
address
CrvDepositorWrapper address
_outputBps
uint256
Min output base points
function setKeeper(address _keeper) external
Set keeper
function setPendingOwner(address _po) external
Set pending owner
function applyPendingOwner() external
Apply pending owner
function setCallIncentive(uint256 _incentive) external
Set call incentive
_incentive
uint256
Incentive base points
function setRewards(address _rewards) external
Set reward address
function setApprovals() external
Approve crvDepositorWrapper to transfer contract CRV and rewards to transfer cvxCrv
function rescueToken(address _token, address _to) external
Transfer stuck ERC20 tokens to _to
function distribute(uint256 _minOut) external
function distribute() external
Collects cvxCRV rewards from cvxRewardPool, converts any CRV deposited directly from the booster, and then applies the rewards to the cvxLocker, rewarding the caller in the process.
function _distribute(uint256 _minOut) internal
function distributeOther(contract IERC20 _token) external
Allow generic token distribution in case a new reward is ever added
Vests tokens over a given timeframe to an array of recipients. Allows locking of these tokens directly to staking contract.
Adaptations: - One time initialisation - Consolidation of fundAdmin/admin - Lock in AuraLocker by default - Start and end time
contract IERC20 rewardToken
address admin
address funder
contract IAuraLocker auraLocker
uint256 startTime
uint256 endTime
uint256 totalTime
bool initialised
mapping(address => uint256) totalLocked
mapping(address => uint256) totalClaimed
event Funded(address recipient, uint256 reward)
event Cancelled(address recipient)
event Claim(address user, uint256 amount, bool locked)
constructor(address rewardToken_, address admin_, address auraLocker_, uint256 starttime_, uint256 endtime_) public
rewardToken_
address
Reward token (AURA)
admin_
address
Admin to cancel rewards
auraLocker_
address
Contract where rewardToken can be staked
starttime_
uint256
Timestamp when claim starts
endtime_
uint256
When vesting ends
function setAdmin(address _admin) external
Change contract admin
_admin
address
New admin address
function setLocker(address _auraLocker) external
Change locker contract address
_auraLocker
address
Aura Locker address
function fund(address[] _recipient, uint256[] _amount) external
Fund recipients with rewardTokens
_recipient
address[]
Array of recipients to vest rewardTokens for
_amount
uint256[]
Arrary of amount of rewardTokens to vest
function cancel(address _recipient) external
Cancel recipients vesting rewardTokens
_recipient
address
Recipient address
function available(address _recipient) public view returns (uint256)
Available amount to claim
_recipient
address
Recipient to lookup
function remaining(address _recipient) public view returns (uint256)
Total remaining vested amount
_recipient
address
Recipient to lookup
function _totalVestedOf(address _recipient, uint256 _time) internal view returns (uint256 total)
Get total amount vested for this timestamp
_recipient
address
Recipient to lookup
_time
uint256
Timestamp to check vesting amount for
function claim(bool _lock) external
function _claim(address _recipient, bool _lock) internal
Claim reward token (Aura) and lock it.
_recipient
address
Address to receive rewards.
_lock
bool
Lock rewards immediately.
Deposits $BAL into a BAL/WETH BPT. Hooks into TWAP to determine minOut.
Abstract contract for depositing BAL -> balBPT -> auraBAL via crvDepositor
contract IVault BALANCER_VAULT
address BAL
address WETH
address BALANCER_POOL_TOKEN
bytes32 BAL_ETH_POOL_ID
constructor(contract IVault _balancerVault, address _bal, address _weth, bytes32 _balETHPoolId) internal
function _setApprovals() internal
function _getBptPrice() internal view returns (uint256)
function _getMinOut(uint256 amount, uint256 minOutBps) internal view returns (uint256)
function _investBalToPool(uint256 amount, uint256 minOut) internal
Provides initial liquidity to a Balancer pool on behalf of a given DAO
contract IERC20 startToken
contract IERC20 pairToken
uint256 minPairAmount
address provider
address dao
contract IVault bVault
event LiquidityProvided(uint256[] input, uint256 output)
event MinPairAmountChanged(uint256 oldMinPairAmount, uint256 newMinPairAmount)
constructor(address _startToken, address _pairToken, uint256 _minPairAmount, address _dao, address _bVault) public
function provideLiquidity(bytes32 _poolId, struct IVault.JoinPoolRequest _request) public
Provides liquidity on behalf of the dao, in a non-custodial manner. Has protections in place to ensure that no erroneous liquidity data gets added.
function changeMinPairAmount(uint256 _newAmount) external
Allows the DAO to change the minimum amount of the pair token that must be added as liquidity
function rescueToken(address _erc20, uint256 _amount) external
Rescues a given token from the contract. Only provider or DAO can call this function.
uint256 pid
address briber
address chef
constructor(address _chef) public
function setBriber(address _briber) external
function setPid(uint256 _pid) external
function deposit(address siphonToken) external
function claim(address token) external
Allows anyone to distribute rewards to the AuraLocker at a given epoch.
contract IAuraLocker auraLocker
mapping(address => bool) canAddReward
mapping(address => mapping(uint256 => uint256)) rewardData
mapping(address => uint256[]) rewardEpochs
mapping(address => mapping(address => uint256)) userClaims
event WhitelistModified(address user, bool canAdd)
event RewardAdded(address token, uint256 epoch, uint256 reward)
event RewardPaid(address user, address token, uint256 reward, uint256 index)
event RewardForfeited(address user, address token, uint256 index)
constructor(address _auraLocker) public
Simple constructor
_auraLocker
address
Aura Locker address
function modifyWhitelist(address _depositor, bool _canAdd) external
function addReward(address _token, uint256 _amount) external
Add a reward to the current epoch. can be called multiple times for the same reward token
_token
address
Reward token address
_amount
uint256
Amount of reward tokenπ
function addRewardToEpoch(address _token, uint256 _amount, uint256 _epoch) external
Add reward token to a specific epoch
_token
address
Reward token address
_amount
uint256
Amount of reward tokens to add
_epoch
uint256
Which epoch to add to (must be less than the previous epoch)
function _addReward(address _token, uint256 _amount, uint256 _epoch) internal
Transfer reward tokens from sender to contract for vlCVX holders
Add reward token for specific epoch
_token
address
Reward token address
_amount
uint256
Amount of reward tokens
_epoch
uint256
Epoch to add tokens to
function getReward(address _account, address _token) public
Claim rewards for a specific token since the first epoch.
_account
address
Address of vlCVX holder
_token
address
Reward token address
function getReward(address _token, uint256 _startIndex) public
Claim rewards for a specific token at a specific epoch
_token
address
Reward token address
_startIndex
uint256
Index of rewardEpochs[_token] to start checking for rewards from
function _getReward(address _account, address _token, uint256 _startIndex) internal
Claim rewards for a specific token at a specific epoch
_account
address
Address of vlCVX holder
_token
address
Reward token address
_startIndex
uint256
Index of rewardEpochs[_token] to start checking for rewards from
function forfeitRewards(address _token, uint256 _index) external
Allow a user to set their claimed index forward without claiming rewards Because claims cycle through all periods that a specific reward was given there becomes a situation where, for example, a new user could lock 2 years from now and try to claim a token that was given out every week prior. This would result in a 2mil gas checkpoint.(about 20k gas * 52 weeks * 2 years)
_token
address
Reward token to forfeit
_index
uint256
Epoch index to forfeit from
function claimableRewards(address _account, address _token) external view returns (uint256)
Get claimable rewards (rewardToken) for vlCVX holder
_account
address
Address of vlCVX holder
_token
address
Reward token address
function claimableRewardsAtEpoch(address _account, address _token, uint256 _epoch) external view returns (uint256)
Get claimable rewards for a token at a specific epoch
_account
address
Address of vlCVX holder
_token
address
Reward token address
_epoch
uint256
The epoch to check for rewards
function _allClaimableRewards(address _account, address _token, uint256 _startIndex) internal view returns (uint256, uint256)
Get all claimable rewards by looping through each epoch starting with the latest saved epoch the user last claimed from
_account
address
Address of vlCVX holder
_token
address
Reward token
_startIndex
uint256
Index of rewardEpochs[_token] to start checking for rewards from
function _claimableRewards(address _account, address _token, uint256 _epoch) internal view returns (uint256)
Get claimable rewards for a token at a specific epoch
_account
address
Address of vlCVX holder
_token
address
Reward token address
_epoch
uint256
The epoch to check for rewards
function rewardEpochsCount(address _token) external view returns (uint256)
Simply gets the current epoch count for a given reward token
_token
address
Reward token address
[0]
uint256
_epochs Number of epochs
function deposit(uint256 assets, address receiver) external returns (uint256 shares)
Peripheral contract that allows users to deposit into a Balancer pool and then stake their BPT into Aura in 1 tx. Flow: - rawToken.transferFrom(user, address(this)) - vault.deposit(rawToken), receive poolToken - poolToken.approve(rewardPool) - rewardPool.deposit(poolToken), converts to auraBPT and then deposits
contract IVault bVault
constructor(address _bVault) public
function depositSingle(address _rewardPoolAddress, contract IERC20 _inputToken, uint256 _inputAmount, bytes32 _balancerPoolId, struct IVault.JoinPoolRequest _request) external
Deposits a single raw token into a BPT before depositing in reward pool. Requires sender to approve this contract before calling.