Solidity API

Documentation generated with solidity-docgen

AuraToken

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.

operator

address operator

vecrvProxy

address vecrvProxy

EMISSIONS_MAX_SUPPLY

uint256 EMISSIONS_MAX_SUPPLY

INIT_MINT_AMOUNT

uint256 INIT_MINT_AMOUNT

totalCliffs

uint256 totalCliffs

reductionPerCliff

uint256 reductionPerCliff

minter

address minter

minterMinted

uint256 minterMinted

Initialised

event Initialised()

OperatorChanged

event OperatorChanged(address previousOperator, address newOperator)

constructor

constructor(address _proxy, string _nameArg, string _symbolArg) public

Name	Type	Description
_proxy	address	CVX VoterProxy
_nameArg	string	Token name
_symbolArg	string	Token symbol

init

function init(address _to, address _minter) external

Initialise and mints initial supply of tokens.

Name	Type	Description
_to	address	Target address to mint.
_minter	address	The minter address.

updateOperator

function updateOperator() public

This can be called if the operator of the voterProxy somehow changes.

mint

function mint(address _to, uint256 _amount) external

Mints AURA to a given user based on the BAL supply schedule.

minterMint

function minterMint(address _to, uint256 _amount) external

Allows minter to mint to a specific address

AuraBalRewardPool

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%

rewardToken

contract IERC20 rewardToken

stakingToken

contract IERC20 stakingToken

duration

uint256 duration

rewardManager

address rewardManager

auraLocker

contract IAuraLocker auraLocker

penaltyForwarder

address penaltyForwarder

pendingPenalty

uint256 pendingPenalty

startTime

uint256 startTime

periodFinish

uint256 periodFinish

rewardRate

uint256 rewardRate

lastUpdateTime

uint256 lastUpdateTime

rewardPerTokenStored

uint256 rewardPerTokenStored

_totalSupply

uint256 _totalSupply

userRewardPerTokenPaid

mapping(address => uint256) userRewardPerTokenPaid

rewards

mapping(address => uint256) rewards

_balances

mapping(address => uint256) _balances

RewardAdded

event RewardAdded(uint256 reward)

Staked

event Staked(address user, uint256 amount)

Withdrawn

event Withdrawn(address user, uint256 amount)

RewardPaid

event RewardPaid(address user, uint256 reward, bool locked)

PenaltyForwarded

event PenaltyForwarded(uint256 amount)

Rescued

event Rescued()

constructor

constructor(address _stakingToken, address _rewardToken, address _rewardManager, address _auraLocker, address _penaltyForwarder, uint256 _startDelay) public

Simple constructor

Name	Type	Description
_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

totalSupply

function totalSupply() public view returns (uint256)

balanceOf

function balanceOf(address account) public view returns (uint256)

updateReward

modifier updateReward(address account)

lastTimeRewardApplicable

function lastTimeRewardApplicable() public view returns (uint256)

rewardPerToken

function rewardPerToken() public view returns (uint256)

earned

function earned(address account) public view returns (uint256)

stake

function stake(uint256 _amount) public returns (bool)

stakeAll

function stakeAll() external returns (bool)

stakeFor

function stakeFor(address _for, uint256 _amount) public returns (bool)

withdraw

function withdraw(uint256 amount, bool claim, bool lock) public returns (bool)

getReward

function getReward(bool _lock) public returns (bool)

Gives a staker their rewards

Name	Type	Description
_lock	bool	Lock the rewards? If false, takes a 20% haircut

forwardPenalty

function forwardPenalty() public

Forwards to the penalty forwarder for distro to Aura Lockers

rescueReward

function rescueReward() public

Rescues the reward token provided it hasn't been initiated yet

setLocker

function setLocker(address _newLocker) external

Updates the locker address

initialiseRewards

function initialiseRewards() external returns (bool)

Called once to initialise the rewards based on balance of stakeToken

AuraClaimZap

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

crv

address crv

cvx

address cvx

cvxCrv

address cvxCrv

crvDepositWrapper

address crvDepositWrapper

cvxCrvRewards

address cvxCrvRewards

locker

address locker

owner

address owner

Options

enum Options {
  ClaimCvxCrv,
  ClaimLockedCvx,
  ClaimLockedCvxStake,
  LockCrvDeposit,
  UseAllWalletFunds,
  LockCvx
}

constructor

constructor(address _crv, address _cvx, address _cvxCrv, address _crvDepositWrapper, address _cvxCrvRewards, address _locker) public

Name	Type	Description
_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);

getName

function getName() external pure returns (string)

setApprovals

function setApprovals() external

Approve spending of: crv -> crvDepositor cvxCrv -> cvxCrvRewards cvx -> Locker

_checkOption

function _checkOption(uint256 _mask, uint256 _flag) internal pure returns (bool)

Use bitmask to check if option flag is set

claimRewards

function claimRewards(address[] rewardContracts, address[] extraRewardContracts, address[] tokenRewardContracts, address[] tokenRewardTokens, uint256 depositCrvMaxAmount, uint256 minAmountOut, uint256 depositCvxMaxAmount, uint256 options) external

Claim all the rewards

Name	Type	Description
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

_claimExtras

function _claimExtras(uint256 depositCrvMaxAmount, uint256 minAmountOut, uint256 depositCvxMaxAmount, uint256 removeCrvBalance, uint256 removeCvxBalance, uint256 options) internal

Claim additional rewards from: - cvxCrvRewards - cvxLocker

Name	Type	Description
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

AuraLocker

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.

RewardData

struct RewardData {
  uint32 periodFinish;
  uint32 lastUpdateTime;
  uint96 rewardRate;
  uint96 rewardPerTokenStored;
}

UserData

struct UserData {
  uint128 rewardPerTokenPaid;
  uint128 rewards;
}

EarnedData

struct EarnedData {
  address token;
  uint256 amount;
}

Balances

struct Balances {
  uint112 locked;
  uint32 nextUnlockIndex;
}

LockedBalance

struct LockedBalance {
  uint112 amount;
  uint32 unlockTime;
}

Epoch

struct Epoch {
  uint224 supply;
  uint32 date;
}

DelegateeCheckpoint

struct DelegateeCheckpoint {
  uint224 votes;
  uint32 epochStart;
}

rewardTokens

address[] rewardTokens

queuedRewards

mapping(address => uint256) queuedRewards

newRewardRatio

uint256 newRewardRatio

rewardData

mapping(address => struct AuraLocker.RewardData) rewardData

rewardDistributors

mapping(address => mapping(address => bool)) rewardDistributors

userData

mapping(address => mapping(address => struct AuraLocker.UserData)) userData

rewardsDuration

uint256 rewardsDuration

lockDuration

uint256 lockDuration

lockedSupply

uint256 lockedSupply

epochs

struct AuraLocker.Epoch[] epochs

balances

mapping(address => struct AuraLocker.Balances) balances

userLocks

mapping(address => struct AuraLocker.LockedBalance[]) userLocks

_delegates

mapping(address => address) _delegates

_checkpointedVotes

mapping(address => struct AuraLocker.DelegateeCheckpoint[]) _checkpointedVotes

delegateeUnlocks

mapping(address => mapping(uint256 => uint256)) delegateeUnlocks

blacklist

mapping(address => bool) blacklist

stakingToken

contract IERC20 stakingToken

cvxCrv

address cvxCrv

denominator

uint256 denominator

cvxcrvStaking

address cvxcrvStaking

kickRewardPerEpoch

uint256 kickRewardPerEpoch

kickRewardEpochDelay

uint256 kickRewardEpochDelay

isShutdown

bool isShutdown

_name

string _name

_symbol

string _symbol

_decimals

uint8 _decimals

DelegateChanged

event DelegateChanged(address delegator, address fromDelegate, address toDelegate)

DelegateCheckpointed

event DelegateCheckpointed(address delegate)

Recovered

event Recovered(address _token, uint256 _amount)

RewardPaid

event RewardPaid(address _user, address _rewardsToken, uint256 _reward)

Staked

event Staked(address _user, uint256 _paidAmount, uint256 _lockedAmount)

Withdrawn

event Withdrawn(address _user, uint256 _amount, bool _relocked)

KickReward

event KickReward(address _user, address _kicked, uint256 _reward)

RewardAdded

event RewardAdded(address _token, uint256 _reward)

BlacklistModified

event BlacklistModified(address account, bool blacklisted)

KickIncentiveSet

event KickIncentiveSet(uint256 rate, uint256 delay)

Shutdown

event Shutdown()

constructor

constructor(string _nameArg, string _symbolArg, address _stakingToken, address _cvxCrv, address _cvxCrvStaking) public

Name	Type	Description
_nameArg	string	Token name, simples
_symbolArg	string	Token symbol
_stakingToken	address	CVX (0x4e3FBD56CD56c3e72c1403e103b45Db9da5B9D2B)
_cvxCrv	address	cvxCRV (0x62B9c7356A2Dc64a1969e19C23e4f579F9810Aa7)
_cvxCrvStaking	address	cvxCRV rewards (0x3Fe65692bfCD0e6CF84cB1E7d24108E434A7587e)

updateReward

modifier updateReward(address _account)

notBlacklisted

modifier notBlacklisted(address _sender, address _receiver)

modifyBlacklist

function modifyBlacklist(address _account, bool _blacklisted) external

addReward

function addReward(address _rewardsToken, address _distributor) external

approveRewardDistributor

function approveRewardDistributor(address _rewardsToken, address _distributor, bool _approved) external

setKickIncentive

function setKickIncentive(uint256 _rate, uint256 _delay) external

shutdown

function shutdown() external

recoverERC20

function recoverERC20(address _tokenAddress, uint256 _tokenAmount) external

setApprovals

function setApprovals() external

lock

function lock(address _account, uint256 _amount) external

_lock

function _lock(address _account, uint256 _amount) internal

getReward

function getReward(address _account) external

getReward

function getReward(address _account, bool _stake) public

getReward

function getReward(address _account, bool[] _skipIdx) external

checkpointEpoch

function checkpointEpoch() external

_checkpointEpoch

function _checkpointEpoch() internal

processExpiredLocks

function processExpiredLocks(bool _relock) external

kickExpiredLocks

function kickExpiredLocks(address _account) external

emergencyWithdraw

function emergencyWithdraw() external

_processExpiredLocks

function _processExpiredLocks(address _account, bool _relock, address _rewardAddress, uint256 _checkDelay) internal

delegate

function delegate(address newDelegatee) external virtual

Delegate votes from the sender to newDelegatee.

_checkpointDelegate

function _checkpointDelegate(address _account, uint256 _upcomingAddition, uint256 _upcomingDeduction) internal

delegates

function delegates(address account) public view virtual returns (address)

Get the address account is currently delegating to.

getVotes

function getVotes(address account) external view returns (uint256)

Gets the current votes balance for account

checkpoints

function checkpoints(address account, uint32 pos) external view virtual returns (struct AuraLocker.DelegateeCheckpoint)

Get the pos-th checkpoint for account.

numCheckpoints

function numCheckpoints(address account) external view virtual returns (uint32)

Get number of checkpoints for account.

getPastVotes

function getPastVotes(address account, uint256 timestamp) public view returns (uint256 votes)

Retrieve the number of votes for account at the end of blockNumber.

getPastTotalSupply

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!

_checkpointsLookup

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

balanceOf

function balanceOf(address _user) external view returns (uint256 amount)

balanceAtEpochOf

function balanceAtEpochOf(uint256 _epoch, address _user) public view returns (uint256 amount)

lockedBalances

function lockedBalances(address _user) external view returns (uint256 total, uint256 unlockable, uint256 locked, struct AuraLocker.LockedBalance[] lockData)

totalSupply

function totalSupply() external view returns (uint256 supply)

totalSupplyAtEpoch

function totalSupplyAtEpoch(uint256 _epoch) public view returns (uint256 supply)

findEpochId

function findEpochId(uint256 _time) public view returns (uint256 epoch)

epochCount

function epochCount() external view returns (uint256)

decimals

function decimals() external view returns (uint8)

name

function name() external view returns (string)

symbol

function symbol() external view returns (string)

claimableRewards

function claimableRewards(address _account) external view returns (struct AuraLocker.EarnedData[] userRewards)

lastTimeRewardApplicable

function lastTimeRewardApplicable(address _rewardsToken) external view returns (uint256)

rewardPerToken

function rewardPerToken(address _rewardsToken) external view returns (uint256)

_earned

function _earned(address _user, address _rewardsToken, uint256 _balance) internal view returns (uint256)

_lastTimeRewardApplicable

function _lastTimeRewardApplicable(uint256 _finishTime) internal view returns (uint256)

_rewardPerToken

function _rewardPerToken(address _rewardsToken) internal view returns (uint256)

queueNewRewards

function queueNewRewards(address _rewardsToken, uint256 _rewards) external

_notifyReward

function _notifyReward(address _rewardsToken, uint256 _reward) internal

AuraMerkleDrop

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)

dao

address dao

merkleRoot

bytes32 merkleRoot

aura

contract IERC20 aura

auraLocker

contract IAuraLocker auraLocker

penaltyForwarder

address penaltyForwarder

pendingPenalty

uint256 pendingPenalty

deployTime

uint256 deployTime

startTime

uint256 startTime

expiryTime

uint256 expiryTime

hasClaimed

mapping(address => bool) hasClaimed

DaoSet

event DaoSet(address newDao)

RootSet

event RootSet(bytes32 newRoot)

StartedEarly

event StartedEarly()

ExpiredWithdrawn

event ExpiredWithdrawn(uint256 amount)

LockerSet

event LockerSet(address newLocker)

Claimed

event Claimed(address addr, uint256 amt, bool locked)

PenaltyForwarded

event PenaltyForwarded(uint256 amount)

Rescued

event Rescued()

constructor

constructor(address _dao, bytes32 _merkleRoot, address _aura, address _auraLocker, address _penaltyForwarder, uint256 _startDelay, uint256 _expiresAfter) public

Name	Type	Description
_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

setDao

function setDao(address _newDao) external

setRoot

function setRoot(bytes32 _merkleRoot) external

startEarly

function startEarly() external

withdrawExpired

function withdrawExpired() external

setLocker

function setLocker(address _newLocker) external

rescueReward

function rescueReward() public

claim

function claim(bytes32[] _proof, uint256 _amount, bool _lock) public returns (bool)

forwardPenalty

function forwardPenalty() public

AuraMinter

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.

aura

contract AuraToken aura

Aura token

inflationProtectionTime

uint256 inflationProtectionTime

Timestamp upon which minting will be possible

constructor

constructor(address _aura, address _dao) public

mint

function mint(address _to, uint256 _amount) external

Mint function allows the owner of the contract to inflate AURA post protection time

Name	Type	Description
_to	address	Recipient address
_amount	uint256	Amount of tokens

AuraPenaltyForwarder

Receives a given token and forwards it on to a distribution contract.

distributor

contract IExtraRewardsDistributor distributor

token

contract IERC20 token

distributionDelay

uint256 distributionDelay

lastDistribution

uint256 lastDistribution

Forwarded

event Forwarded(uint256 amount)

DistributorChanged

event DistributorChanged(address newDistributor)

constructor

constructor(address _distributor, address _token, uint256 _delay, address _dao) public

During deployment approves the distributor to spend all tokens

Name	Type	Description
_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

forward

function forward() public

Forwards the complete balance of token in this contract to the distributor

setDistributor

function setDistributor(address _distributor) public

Updates distributor address

AuraStakingProxy

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

crv

address crv

cvx

address cvx

cvxCrv

address cvxCrv

keeper

address keeper

crvDepositorWrapper

address crvDepositorWrapper

outputBps

uint256 outputBps

denominator

uint256 denominator

rewards

address rewards

owner

address owner

pendingOwner

address pendingOwner

callIncentive

uint256 callIncentive

RewardsDistributed

event RewardsDistributed(address token, uint256 amount)

CallIncentiveChanged

event CallIncentiveChanged(uint256 incentive)

constructor

constructor(address _rewards, address _crv, address _cvx, address _cvxCrv, address _crvDepositorWrapper, uint256 _outputBps) public

Name	Type	Description
_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

setCrvDepositorWrapper

function setCrvDepositorWrapper(address _crvDepositorWrapper, uint256 _outputBps) external

Set CrvDepositorWrapper

Name	Type	Description
_crvDepositorWrapper	address	CrvDepositorWrapper address
_outputBps	uint256	Min output base points

setKeeper

function setKeeper(address _keeper) external

Set keeper

setPendingOwner

function setPendingOwner(address _po) external

Set pending owner

applyPendingOwner

function applyPendingOwner() external

Apply pending owner

setCallIncentive

function setCallIncentive(uint256 _incentive) external

Set call incentive

Name	Type	Description
_incentive	uint256	Incentive base points

setRewards

function setRewards(address _rewards) external

Set reward address

setApprovals

function setApprovals() external

Approve crvDepositorWrapper to transfer contract CRV and rewards to transfer cvxCrv

rescueToken

function rescueToken(address _token, address _to) external

Transfer stuck ERC20 tokens to _to

distribute

function distribute(uint256 _minOut) external

distribute

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.

_distribute

function _distribute(uint256 _minOut) internal

distributeOther

function distributeOther(contract IERC20 _token) external

Allow generic token distribution in case a new reward is ever added

AuraVestedEscrow

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

rewardToken

contract IERC20 rewardToken

admin

address admin

funder

address funder

auraLocker

contract IAuraLocker auraLocker

startTime

uint256 startTime

endTime

uint256 endTime

totalTime

uint256 totalTime

initialised

bool initialised

totalLocked

mapping(address => uint256) totalLocked

totalClaimed

mapping(address => uint256) totalClaimed

Funded

event Funded(address recipient, uint256 reward)

Cancelled

event Cancelled(address recipient)

Claim

event Claim(address user, uint256 amount, bool locked)

constructor

constructor(address rewardToken_, address admin_, address auraLocker_, uint256 starttime_, uint256 endtime_) public

Name	Type	Description
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

setAdmin

function setAdmin(address _admin) external

Change contract admin

Name	Type	Description
_admin	address	New admin address

setLocker

function setLocker(address _auraLocker) external

Change locker contract address

Name	Type	Description
_auraLocker	address	Aura Locker address

fund

function fund(address[] _recipient, uint256[] _amount) external

Fund recipients with rewardTokens

Name	Type	Description
_recipient	address[]	Array of recipients to vest rewardTokens for
_amount	uint256[]	Arrary of amount of rewardTokens to vest

cancel

function cancel(address _recipient) external

Cancel recipients vesting rewardTokens

Name	Type	Description
_recipient	address	Recipient address

available

function available(address _recipient) public view returns (uint256)

Available amount to claim

Name	Type	Description
_recipient	address	Recipient to lookup

remaining

function remaining(address _recipient) public view returns (uint256)

Total remaining vested amount

Name	Type	Description
_recipient	address	Recipient to lookup

_totalVestedOf

function _totalVestedOf(address _recipient, uint256 _time) internal view returns (uint256 total)

Get total amount vested for this timestamp

Name	Type	Description
_recipient	address	Recipient to lookup
_time	uint256	Timestamp to check vesting amount for

claim

function claim(bool _lock) external

_claim

function _claim(address _recipient, bool _lock) internal

Claim reward token (Aura) and lock it.

Name	Type	Description
_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

BALANCER_VAULT

contract IVault BALANCER_VAULT

BAL

address BAL

WETH

address WETH

BALANCER_POOL_TOKEN

address BALANCER_POOL_TOKEN

BAL_ETH_POOL_ID

bytes32 BAL_ETH_POOL_ID

constructor

constructor(contract IVault _balancerVault, address _bal, address _weth, bytes32 _balETHPoolId) internal

_setApprovals

function _setApprovals() internal

_getBptPrice

function _getBptPrice() internal view returns (uint256)

_getMinOut

function _getMinOut(uint256 amount, uint256 minOutBps) internal view returns (uint256)

_investBalToPool

function _investBalToPool(uint256 amount, uint256 minOut) internal

BalLiquidityProvider

Provides initial liquidity to a Balancer pool on behalf of a given DAO

startToken

contract IERC20 startToken

pairToken

contract IERC20 pairToken

minPairAmount

uint256 minPairAmount

provider

address provider

dao

address dao

bVault

contract IVault bVault

LiquidityProvided

event LiquidityProvided(uint256[] input, uint256 output)

MinPairAmountChanged

event MinPairAmountChanged(uint256 oldMinPairAmount, uint256 newMinPairAmount)

constructor

constructor(address _startToken, address _pairToken, uint256 _minPairAmount, address _dao, address _bVault) public

provideLiquidity

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.

changeMinPairAmount

function changeMinPairAmount(uint256 _newAmount) external

Allows the DAO to change the minimum amount of the pair token that must be added as liquidity

rescueToken

function rescueToken(address _erc20, uint256 _amount) external

Rescues a given token from the contract. Only provider or DAO can call this function.

ChefForwarder

pid

uint256 pid

briber

address briber

chef

address chef

constructor

constructor(address _chef) public

setBriber

function setBriber(address _briber) external

setPid

function setPid(uint256 _pid) external

deposit

function deposit(address siphonToken) external

claim

function claim(address token) external

ExtraRewardsDistributor

Allows anyone to distribute rewards to the AuraLocker at a given epoch.

auraLocker

contract IAuraLocker auraLocker

canAddReward

mapping(address => bool) canAddReward

rewardData

mapping(address => mapping(uint256 => uint256)) rewardData

rewardEpochs

mapping(address => uint256[]) rewardEpochs

userClaims

mapping(address => mapping(address => uint256)) userClaims

WhitelistModified

event WhitelistModified(address user, bool canAdd)

RewardAdded

event RewardAdded(address token, uint256 epoch, uint256 reward)

RewardPaid

event RewardPaid(address user, address token, uint256 reward, uint256 index)

RewardForfeited

event RewardForfeited(address user, address token, uint256 index)

constructor

constructor(address _auraLocker) public

Simple constructor

Name	Type	Description
_auraLocker	address	Aura Locker address

modifyWhitelist

function modifyWhitelist(address _depositor, bool _canAdd) external

addReward

function addReward(address _token, uint256 _amount) external

Add a reward to the current epoch. can be called multiple times for the same reward token

Name	Type	Description
_token	address	Reward token address
_amount	uint256	Amount of reward tokenπ

addRewardToEpoch

function addRewardToEpoch(address _token, uint256 _amount, uint256 _epoch) external

Add reward token to a specific epoch

Name	Type	Description
_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)

_addReward

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

Name	Type	Description
_token	address	Reward token address
_amount	uint256	Amount of reward tokens
_epoch	uint256	Epoch to add tokens to

getReward

function getReward(address _account, address _token) public

Claim rewards for a specific token since the first epoch.

Name	Type	Description
_account	address	Address of vlCVX holder
_token	address	Reward token address

getReward

function getReward(address _token, uint256 _startIndex) public

Claim rewards for a specific token at a specific epoch

Name	Type	Description
_token	address	Reward token address
_startIndex	uint256	Index of rewardEpochs[_token] to start checking for rewards from

_getReward

function _getReward(address _account, address _token, uint256 _startIndex) internal

Claim rewards for a specific token at a specific epoch

Name	Type	Description
_account	address	Address of vlCVX holder
_token	address	Reward token address
_startIndex	uint256	Index of rewardEpochs[_token] to start checking for rewards from

forfeitRewards

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)

Name	Type	Description
_token	address	Reward token to forfeit
_index	uint256	Epoch index to forfeit from

claimableRewards

function claimableRewards(address _account, address _token) external view returns (uint256)

Get claimable rewards (rewardToken) for vlCVX holder

Name	Type	Description
_account	address	Address of vlCVX holder
_token	address	Reward token address

claimableRewardsAtEpoch

function claimableRewardsAtEpoch(address _account, address _token, uint256 _epoch) external view returns (uint256)

Get claimable rewards for a token at a specific epoch

Name	Type	Description
_account	address	Address of vlCVX holder
_token	address	Reward token address
_epoch	uint256	The epoch to check for rewards

_allClaimableRewards

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

Name	Type	Description
_account	address	Address of vlCVX holder
_token	address	Reward token
_startIndex	uint256	Index of rewardEpochs[_token] to start checking for rewards from

_claimableRewards

function _claimableRewards(address _account, address _token, uint256 _epoch) internal view returns (uint256)

Get claimable rewards for a token at a specific epoch

Name	Type	Description
_account	address	Address of vlCVX holder
_token	address	Reward token address
_epoch	uint256	The epoch to check for rewards

rewardEpochsCount

function rewardEpochsCount(address _token) external view returns (uint256)

Simply gets the current epoch count for a given reward token

Name	Type	Description
_token	address	Reward token address

Name	Type	Description
[0]	uint256	_epochs Number of epochs

RewardPool

deposit

function deposit(uint256 assets, address receiver) external returns (uint256 shares)

RewardPoolDepositWrapper

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

bVault

contract IVault bVault

constructor

constructor(address _bVault) public

depositSingle

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.