Contract Name:
FeeRecipient
Contract Source Code:
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import {IERC20} from "@openzeppelin/contracts/interfaces/IERC20.sol";
import {IFeeDistributor} from "./interfaces/IFeeDistributor.sol";
import {IFeeRecipient} from "./interfaces/IFeeRecipient.sol";
import {IFeeRecipientFactory} from "./interfaces/IFeeRecipientFactory.sol";
import {Errors} from "contracts/libraries/Errors.sol";
/// @notice Pair Fees contract is used as a 1:1 pair relationship to split out fees, this ensures that the curve does not need to be modified for LP shares
contract FeeRecipient is IFeeRecipient {
/// @notice The pair it is bonded to
address public immutable pair;
/// @notice voter contract which fees are gated to be claimed by
address public immutable voter;
/// @notice feedist contract where fees will be sent to
address public feeDistributor;
/// @notice factory contract for feeRecipient (legacy fees)
address public immutable feeRecipientFactory;
uint256 internal constant FEE_DENOM = 1_000_000;
constructor(address _pair, address _voter, address _feeRecipientFactory) {
pair = _pair;
voter = _voter;
feeRecipientFactory = _feeRecipientFactory;
}
/// @notice initialize the FeeRecipient contract and approve the LP tokens to the feeDist, gated to voter
function initialize(address _feeDistributor) external {
require(msg.sender == voter, Errors.NOT_AUTHORIZED(msg.sender));
feeDistributor = _feeDistributor;
IERC20(pair).approve(_feeDistributor, type(uint256).max);
}
/// @notice notifies the fees
function notifyFees() external {
/// @dev fetch balance of LP in the contract
uint256 amount = IERC20(pair).balanceOf(address(this));
/// @dev terminate early if there's no rewards
if (amount == 0) return;
/// @dev calculate treasury share
uint256 feeToTreasury = IFeeRecipientFactory(feeRecipientFactory).feeToTreasury();
/// @dev if any to treasury
if (feeToTreasury > 0) {
/// @dev fetch treasury from factory
address treasury = IFeeRecipientFactory(feeRecipientFactory).treasury();
/// @dev mulDiv
uint256 amountToTreasury = (amount * feeToTreasury) / FEE_DENOM;
/// @dev decrement amount
amount -= amountToTreasury;
/// @dev naked transfer to treasury, no staking
IERC20(pair).transfer(treasury, amountToTreasury);
}
/// @dev if there's any fees
if (amount > 0) {
IFeeDistributor(feeDistributor).notifyRewardAmount(pair, amount);
}
}
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (interfaces/IERC20.sol)
pragma solidity ^0.8.20;
import {IERC20} from "../token/ERC20/IERC20.sol";
// SPDX-License-Identifier: BUSL-1.1
pragma solidity ^0.8.0;
import {IVoter} from "../interfaces/IVoter.sol";
import {IVoteModule} from "../interfaces/IVoteModule.sol";
interface IFeeDistributor {
event Deposit(address owner, uint256 amount);
event Withdraw(address owner, uint256 amount);
event NotifyReward(address indexed from, address indexed reward, uint256 amount, uint256 period);
event VotesIncentivized(address indexed from, address indexed reward, uint256 amount, uint256 period);
event ClaimRewards(uint256 period, address owner, address receiver, address reward, uint256 amount);
event RewardsRedirected(address indexed destination, address indexed _reward, uint256 _amount);
event RewardsRemoved(address _reward);
/// @notice the address of the voter contract
function voter() external view returns (IVoter);
/// @notice the address of the voting module
function voteModule() external view returns (IVoteModule);
/// @notice the address of the feeRecipient contract
function feeRecipient() external view returns (address);
/// @notice the first period (epoch) that this contract was deployed
function firstPeriod() external view returns (uint256);
/// @notice balance of the voting power for a user
/// @param owner the owner
/// @return amount the amount of voting share
function balanceOf(address owner) external view returns (uint256 amount);
/// @notice total cumulative amount of voting power per epoch
/// @param period the period to check
/// @return weight the amount of total voting power
function votes(uint256 period) external view returns (uint256 weight);
/// @notice "internal" function gated to voter to add votes
/// @dev internal notation inherited from original solidly, kept for continuity
function _deposit(uint256 amount, address owner) external;
/// @notice "internal" function gated to voter to remove votes
/// @dev internal notation inherited from original solidly, kept for continuity
function _withdraw(uint256 amount, address owner) external;
/// @notice function to claim rewards on behalf of another
/// @param owner owner's address
/// @param tokens an array of the tokens
function getRewardForOwner(address owner, address[] memory tokens) external;
/// @notice function to claim rewards on behalf of another
/// @param owner owner's address
/// @param tokens an array of the tokens
/// @param destination destination of the rewards
function getRewardForOwnerTo(address owner, address[] memory tokens, address destination) external;
/// @notice function for sending fees directly to be claimable (in system where fees are distro'd through the week)
/// @dev for lumpsum - this would operate similarly to incentivize
/// @param token the address of the token to send for notifying
/// @param amount the amount of token to send
function notifyRewardAmount(address token, uint256 amount) external;
/// @notice gives an array of reward tokens for the feedist
/// @return _rewards array of rewards
function getRewardTokens() external view returns (address[] memory _rewards);
/// @notice shows the earned incentives in the feedist
/// @param token the token address to check
/// @param owner owner's address
/// @return reward the amount earned/claimable
function earned(address token, address owner) external view returns (uint256 reward);
/// @notice function to submit incentives to voters for the upcoming flip
/// @param token the address of the token to send for incentivization
/// @param amount the amount of token to send
function incentivize(address token, uint256 amount) external;
/// @notice get the rewards for a specific period
/// @param owner owner's address
function getPeriodReward(uint256 period, address owner, address token) external;
/// @notice get the fees and incentives
function getReward(address owner, address[] memory tokens) external;
/// @notice remove a reward from the set
function removeReward(address _token) external;
/// @notice claws back rewards
function clawbackRewards(address token, address destination) external;
/// @notice reward supply for a specific period
function rewardSupply(uint256 period, address token) external returns (uint256);
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
interface IFeeRecipient {
function initialize(address _feeDistributor) external;
function notifyFees() external;
}
// SPDX-License-Identifier: GPL-2.0-or-later
pragma solidity ^0.8.0;
interface IFeeRecipientFactory {
/// @notice the pair fees for a specific pair
/// @param pair the pair to check
/// @return feeRecipient the feeRecipient contract address for the pair
function feeRecipientForPair(address pair) external view returns (address feeRecipient);
/// @notice the last feeRecipient address created
/// @return _feeRecipient the address of the last pair fees contract
function lastFeeRecipient() external view returns (address _feeRecipient);
/// @notice create the pair fees for a pair
/// @param pair the address of the pair
/// @return _feeRecipient the address of the newly created feeRecipient
function createFeeRecipient(address pair) external returns (address _feeRecipient);
/// @notice the fee % going to the treasury
/// @return _feeToTreasury the fee %
function feeToTreasury() external view returns (uint256 _feeToTreasury);
/// @notice get the treasury address
/// @return _treasury address of the treasury
function treasury() external view returns (address _treasury);
/// @notice set the fee % to be sent to the treasury
/// @param _feeToTreasury the fee % to be sent to the treasury
function setFeeToTreasury(uint256 _feeToTreasury) external;
/// @notice set a new treasury address
/// @param _treasury the new address
function setTreasury(address _treasury) external;
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
/// @title Central Errors Library
/// @notice Contains all custom errors used across the protocol
/// @dev Centralized error definitions to prevent redundancy
library Errors {
/*//////////////////////////////////////////////////////////////
VOTER ERRORS
//////////////////////////////////////////////////////////////*/
/// @notice Thrown when attempting to interact with an already active gauge
/// @param gauge The address of the gauge
error ACTIVE_GAUGE(address gauge);
/// @notice Thrown when attempting to interact with an inactive gauge
/// @param gauge The address of the gauge
error GAUGE_INACTIVE(address gauge);
/// @notice Thrown when attempting to whitelist an already whitelisted token
/// @param token The address of the token
error ALREADY_WHITELISTED(address token);
/// @notice Thrown when caller is not authorized to perform an action
/// @param caller The address of the unauthorized caller
error NOT_AUTHORIZED(address caller);
/// @notice Thrown when token is not whitelisted
/// @param token The address of the non-whitelisted token
error NOT_WHITELISTED(address token);
/// @notice Thrown when both tokens in a pair are not whitelisted
error BOTH_NOT_WHITELISTED();
/// @notice Thrown when address is not a valid pool
/// @param pool The invalid pool address
error NOT_POOL(address pool);
/// @notice Thrown when pool is not seeded in PoolUpdater
/// @param pool The invalid pool address
error NOT_SEEDED(address pool);
/// @notice Thrown when contract is not initialized
error NOT_INIT();
/// @notice Thrown when array lengths don't match
error LENGTH_MISMATCH();
/// @notice Thrown when pool doesn't have an associated gauge
/// @param pool The address of the pool
error NO_GAUGE(address pool);
/// @notice Thrown when rewards are already distributed for a period
/// @param gauge The gauge address
/// @param period The distribution period
error ALREADY_DISTRIBUTED(address gauge, uint256 period);
/// @notice Thrown when attempting to vote with zero amount
/// @param pool The pool address
error ZERO_VOTE(address pool);
/// @notice Thrown when ratio exceeds maximum allowed
/// @param _xRatio The excessive ratio value
error RATIO_TOO_HIGH(uint256 _xRatio);
/// @notice Thrown when vote operation fails
error VOTE_UNSUCCESSFUL();
/*//////////////////////////////////////////////////////////////
GAUGE V3 ERRORS
//////////////////////////////////////////////////////////////*/
/// @notice Thrown when the pool already has a gauge
/// @param pool The address of the pool
error GAUGE_EXISTS(address pool);
/// @notice Thrown when caller is not the voter
/// @param caller The address of the invalid caller
error NOT_VOTER(address caller);
/// @notice Thrown when amount is not greater than zero
/// @param amt The invalid amount
error NOT_GT_ZERO(uint256 amt);
/// @notice Thrown when attempting to claim future rewards
error CANT_CLAIM_FUTURE();
/// @notice Throw when gauge can't determine if using secondsInRange from the pool is safe
error NEED_TEAM_TO_UPDATE();
/*//////////////////////////////////////////////////////////////
GAUGE ERRORS
//////////////////////////////////////////////////////////////*/
/// @notice Thrown when amount is zero
error ZERO_AMOUNT();
/// @notice Thrown when stake notification fails
error CANT_NOTIFY_STAKE();
/// @notice Thrown when reward amount is too high
error REWARD_TOO_HIGH();
/// @notice Thrown when amount exceeds remaining balance
/// @param amount The requested amount
/// @param remaining The remaining balance
error NOT_GREATER_THAN_REMAINING(uint256 amount, uint256 remaining);
/// @notice Thrown when token operation fails
/// @param token The address of the problematic token
error TOKEN_ERROR(address token);
/// @notice Thrown when an address is not an NfpManager
error NOT_NFP_MANAGER(address nfpManager);
/*//////////////////////////////////////////////////////////////
FEE DISTRIBUTOR ERRORS
//////////////////////////////////////////////////////////////*/
/// @notice Thrown when period is not finalized
/// @param period The unfinalized period
error NOT_FINALIZED(uint256 period);
/// @notice Thrown when the destination of a redirect is not a feeDistributor
/// @param destination Destination of the redirect
error NOT_FEE_DISTRIBUTOR(address destination);
/// @notice Thrown when the destination of a redirect's pool/pair has completely different tokens
error DIFFERENT_DESTINATION_TOKENS();
/*//////////////////////////////////////////////////////////////
PAIR ERRORS
//////////////////////////////////////////////////////////////*/
/// @notice Thrown when ratio is unstable
error UNSTABLE_RATIO();
/// @notice Thrown when safe transfer fails
error SAFE_TRANSFER_FAILED();
/// @notice Thrown on arithmetic overflow
error OVERFLOW();
/// @notice Thrown when skim operation is disabled
error SKIM_DISABLED();
/// @notice Thrown when insufficient liquidity is minted
error INSUFFICIENT_LIQUIDITY_MINTED();
/// @notice Thrown when insufficient liquidity is burned
error INSUFFICIENT_LIQUIDITY_BURNED();
/// @notice Thrown when output amount is insufficient
error INSUFFICIENT_OUTPUT_AMOUNT();
/// @notice Thrown when input amount is insufficient
error INSUFFICIENT_INPUT_AMOUNT();
/// @notice Generic insufficient liquidity error
error INSUFFICIENT_LIQUIDITY();
/// @notice Invalid transfer error
error INVALID_TRANSFER();
/// @notice K value error in AMM
error K();
/*//////////////////////////////////////////////////////////////
PAIR FACTORY ERRORS
//////////////////////////////////////////////////////////////*/
/// @notice Thrown when fee is too high
error FEE_TOO_HIGH();
/// @notice Thrown when fee is zero
error ZERO_FEE();
/// @notice Thrown when token assortment is invalid
error INVALID_ASSORTMENT();
/// @notice Thrown when address is zero
error ZERO_ADDRESS();
/// @notice Thrown when pair already exists
error PAIR_EXISTS();
/// @notice Thrown when fee split is invalid
error INVALID_FEE_SPLIT();
/*//////////////////////////////////////////////////////////////
FEE RECIPIENT FACTORY ERRORS
//////////////////////////////////////////////////////////////*/
/// @notice Thrown when treasury fee is invalid
error INVALID_TREASURY_FEE();
/*//////////////////////////////////////////////////////////////
ROUTER ERRORS
//////////////////////////////////////////////////////////////*/
/// @notice Thrown when deadline has expired
error EXPIRED();
/// @notice Thrown when tokens are identical
error IDENTICAL();
/// @notice Thrown when amount is insufficient
error INSUFFICIENT_AMOUNT();
/// @notice Thrown when path is invalid
error INVALID_PATH();
/// @notice Thrown when token B amount is insufficient
error INSUFFICIENT_B_AMOUNT();
/// @notice Thrown when token A amount is insufficient
error INSUFFICIENT_A_AMOUNT();
/// @notice Thrown when input amount is excessive
error EXCESSIVE_INPUT_AMOUNT();
/// @notice Thrown when ETH transfer fails
error ETH_TRANSFER_FAILED();
/// @notice Thrown when reserves are invalid
error INVALID_RESERVES();
/*//////////////////////////////////////////////////////////////
MINTER ERRORS
//////////////////////////////////////////////////////////////*/
/// @notice Thrown when epoch 0 has already started
error STARTED();
/// @notice Thrown when emissions haven't started
error EMISSIONS_NOT_STARTED();
/// @notice Thrown when deviation is too high
error TOO_HIGH();
/// @notice Thrown when no value change detected
error NO_CHANGE();
/// @notice Thrown when updating emissions in same period
error SAME_PERIOD();
/// @notice Thrown when contract setup is invalid
error INVALID_CONTRACT();
/// @notice Thrown when legacy factory doesn't have feeSplitWhenNoGauge on
error FEE_SPLIT_WHEN_NO_GAUGE_IS_OFF();
/*//////////////////////////////////////////////////////////////
ACCESS HUB ERRORS
//////////////////////////////////////////////////////////////*/
/// @notice Thrown when addresses are identical
error SAME_ADDRESS();
/// @notice Thrown when caller is not timelock
/// @param caller The invalid caller address
error NOT_TIMELOCK(address caller);
/// @notice Thrown when manual execution fails
/// @param reason The failure reason
error MANUAL_EXECUTION_FAILURE(bytes reason);
/// @notice Thrown when kick operation is forbidden
/// @param target The target address
error KICK_FORBIDDEN(address target);
/*//////////////////////////////////////////////////////////////
VOTE MODULE ERRORS
//////////////////////////////////////////////////////////////*/
/// @notice Thrown when caller is not xShadow
error NOT_XSHADOW();
/// @notice Thrown when cooldown period is still active
error COOLDOWN_ACTIVE();
/// @notice Thrown when caller is not vote module
error NOT_VOTEMODULE();
/// @notice Thrown when caller is unauthorized
error UNAUTHORIZED();
/// @notice Thrown when caller is not access hub
error NOT_ACCESSHUB();
/// @notice Thrown when address is invalid
error INVALID_ADDRESS();
/*//////////////////////////////////////////////////////////////
LAUNCHER PLUGIN ERRORS
//////////////////////////////////////////////////////////////*/
/// @notice Thrown when caller is not authority
error NOT_AUTHORITY();
/// @notice Thrown when already an authority
error ALREADY_AUTHORITY();
/// @notice Thrown when caller is not operator
error NOT_OPERATOR();
/// @notice Thrown when already an operator
error ALREADY_OPERATOR();
/// @notice Thrown when pool is not enabled
/// @param pool The disabled pool address
error NOT_ENABLED(address pool);
/// @notice Thrown when fee distributor is missing
error NO_FEEDIST();
/// @notice Thrown when already enabled
error ENABLED();
/// @notice Thrown when take value is invalid
error INVALID_TAKE();
/*//////////////////////////////////////////////////////////////
X33 ERRORS
//////////////////////////////////////////////////////////////*/
/// @notice Thrown when value is zero
error ZERO();
/// @notice Thrown when amount is insufficient
error NOT_ENOUGH();
/// @notice Thrown when value doesn't conform to scale
/// @param value The non-conforming value
error NOT_CONFORMED_TO_SCALE(uint256 value);
/// @notice Thrown when contract is locked
error LOCKED();
/// @notice Thrown when rebase is in progress
error REBASE_IN_PROGRESS();
/// @notice Thrown when aggregator reverts
/// @param reason The revert reason
error AGGREGATOR_REVERTED(bytes reason);
/// @notice Thrown when output amount is too low
/// @param amount The insufficient amount
error AMOUNT_OUT_TOO_LOW(uint256 amount);
/// @notice Thrown when aggregator is not whitelisted
/// @param aggregator The non-whitelisted aggregator address
error AGGREGATOR_NOT_WHITELISTED(address aggregator);
/// @notice Thrown when token is forbidden
/// @param token The forbidden token address
error FORBIDDEN_TOKEN(address token);
/*//////////////////////////////////////////////////////////////
XSHADOW ERRORS
//////////////////////////////////////////////////////////////*/
/// @notice Thrown when caller is not minter
error NOT_MINTER();
/// @notice Thrown when no vest exists
error NO_VEST();
/// @notice Thrown when already exempt
error ALREADY_EXEMPT();
/// @notice Thrown when not exempt
error NOT_EXEMPT();
/// @notice Thrown when rescue operation is not allowed
error CANT_RESCUE();
/// @notice Thrown when array lengths mismatch
error ARRAY_LENGTHS();
/// @notice Thrown when vesting periods overlap
error VEST_OVERLAP();
/*//////////////////////////////////////////////////////////////
V3 FACTORY ERRORS
//////////////////////////////////////////////////////////////*/
/// @notice Thrown when tokens are identical
error IDENTICAL_TOKENS();
/// @notice Thrown when fee is too large
error FEE_TOO_LARGE();
/// @notice Address zero error
error ADDRESS_ZERO();
/// @notice Fee zero error
error F0();
/// @notice Thrown when value is out of bounds
/// @param value The out of bounds value
error OOB(uint8 value);
/*//////////////////////////////////////////////////////////////
POOL UPDATER ERRORS
//////////////////////////////////////////////////////////////*/
/// @notice Thrown when seeding for a pool fails
error TRANSFER_FROM_FOR_SEEDING_FAILED(address token, uint256 amount);
/// @notice Thrown when seeding for a pool fails
error SEEDING_FAILED();
/// @notice Thrown when updatePools is called too early
error TOO_EARLY();
/// @notice Thrown when a callback is called when an update isn't running
error NOT_RUNNING();
/// @notice Thrown when updatePools didn't perform any updates
error NO_UPDATES();
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.1.0) (token/ERC20/IERC20.sol)
pragma solidity ^0.8.20;
/**
* @dev Interface of the ERC-20 standard as defined in the ERC.
*/
interface IERC20 {
/**
* @dev Emitted when `value` tokens are moved from one account (`from`) to
* another (`to`).
*
* Note that `value` may be zero.
*/
event Transfer(address indexed from, address indexed to, uint256 value);
/**
* @dev Emitted when the allowance of a `spender` for an `owner` is set by
* a call to {approve}. `value` is the new allowance.
*/
event Approval(address indexed owner, address indexed spender, uint256 value);
/**
* @dev Returns the value of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the value of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**
* @dev Moves a `value` amount of tokens from the caller's account to `to`.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transfer(address to, uint256 value) external returns (bool);
/**
* @dev Returns the remaining number of tokens that `spender` will be
* allowed to spend on behalf of `owner` through {transferFrom}. This is
* zero by default.
*
* This value changes when {approve} or {transferFrom} are called.
*/
function allowance(address owner, address spender) external view returns (uint256);
/**
* @dev Sets a `value` amount of tokens as the allowance of `spender` over the
* caller's tokens.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* IMPORTANT: Beware that changing an allowance with this method brings the risk
* that someone may use both the old and the new allowance by unfortunate
* transaction ordering. One possible solution to mitigate this race
* condition is to first reduce the spender's allowance to 0 and set the
* desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
*
* Emits an {Approval} event.
*/
function approve(address spender, uint256 value) external returns (bool);
/**
* @dev Moves a `value` amount of tokens from `from` to `to` using the
* allowance mechanism. `value` is then deducted from the caller's
* allowance.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transferFrom(address from, address to, uint256 value) external returns (bool);
}
// SPDX-License-Identifier: BUSL-1.1
pragma solidity ^0.8.0;
pragma abicoder v2;
interface IVoter {
event GaugeCreated(address indexed gauge, address creator, address feeDistributor, address indexed pool);
event GaugeKilled(address indexed gauge);
event GaugeRevived(address indexed gauge);
event Voted(address indexed owner, uint256 weight, address indexed pool);
event Abstained(address indexed owner, uint256 weight);
event Deposit(address indexed lp, address indexed gauge, address indexed owner, uint256 amount);
event Withdraw(address indexed lp, address indexed gauge, address indexed owner, uint256 amount);
event NotifyReward(address indexed sender, address indexed reward, uint256 amount);
event DistributeReward(address indexed sender, address indexed gauge, uint256 amount);
event EmissionsRatio(address indexed caller, uint256 oldRatio, uint256 newRatio);
event NewGovernor(address indexed sender, address indexed governor);
event Whitelisted(address indexed whitelister, address indexed token);
event WhitelistRevoked(address indexed forbidder, address indexed token, bool status);
event MainTickSpacingChanged(address indexed token0, address indexed token1, int24 indexed newMainTickSpacing);
event Poke(address indexed user);
event EmissionsRedirected(address indexed sourceGauge, address indexed destinationGauge);
struct InitializationParams {
address shadow;
address legacyFactory;
address gauges;
address feeDistributorFactory;
address minter;
address msig;
address xShadow;
address clFactory;
address clGaugeFactory;
address nfpManager;
address feeRecipientFactory;
address voteModule;
address launcherPlugin;
address poolUpdater;
}
function initialize(InitializationParams memory inputs) external;
/// @notice denominator basis
function BASIS() external view returns (uint256);
/// @notice ratio of xShadow emissions globally
function xRatio() external view returns (uint256);
/// @notice xShadow contract address
function xShadow() external view returns (address);
/// @notice legacy factory address (uni-v2/stableswap)
function legacyFactory() external view returns (address);
/// @notice concentrated liquidity factory
function clFactory() external view returns (address);
/// @notice gauge factory for CL
function clGaugeFactory() external view returns (address);
/// @notice pool updater for CL
function poolUpdater() external view returns (address);
/// @notice legacy fee recipient factory
function feeRecipientFactory() external view returns (address);
/// @notice peripheral NFPManager contract
function nfpManager() external view returns (address);
/// @notice returns the address of the current governor
/// @return _governor address of the governor
function governor() external view returns (address _governor);
/// @notice the address of the vote module
/// @return _voteModule the vote module contract address
function voteModule() external view returns (address _voteModule);
/// @notice address of the central access Hub
function accessHub() external view returns (address);
/// @notice the address of the shadow launcher plugin to enable third party launchers
/// @return _launcherPlugin the address of the plugin
function launcherPlugin() external view returns (address _launcherPlugin);
/// @notice distributes emissions from the minter to the voter
/// @param amount the amount of tokens to notify
function notifyRewardAmount(uint256 amount) external;
/// @notice distributes the emissions for a specific gauge
/// @param _gauge the gauge address
function distribute(address _gauge) external;
/// @notice returns the address of the gauge factory
/// @param _gaugeFactory gauge factory address
function gaugeFactory() external view returns (address _gaugeFactory);
/// @notice returns the address of the feeDistributor factory
/// @return _feeDistributorFactory feeDist factory address
function feeDistributorFactory() external view returns (address _feeDistributorFactory);
/// @notice returns the address of the minter contract
/// @return _minter address of the minter
function minter() external view returns (address _minter);
/// @notice check if the gauge is active for governance use
/// @param _gauge address of the gauge
/// @return _trueOrFalse if the gauge is alive
function isAlive(address _gauge) external view returns (bool _trueOrFalse);
/// @notice allows the token to be paired with other whitelisted assets to participate in governance
/// @param _token the address of the token
function whitelist(address _token) external;
/// @notice effectively disqualifies a token from governance
/// @param _token the address of the token
function revokeWhitelist(address _token) external;
/// @notice returns if the address is a gauge
/// @param gauge address of the gauge
/// @return _trueOrFalse boolean if the address is a gauge
function isGauge(address gauge) external view returns (bool _trueOrFalse);
/// @notice disable a gauge from governance
/// @param _gauge address of the gauge
function killGauge(address _gauge) external;
/// @notice re-activate a dead gauge
/// @param _gauge address of the gauge
function reviveGauge(address _gauge) external;
/// @notice re-cast a tokenID's votes
/// @param owner address of the owner
function poke(address owner) external;
/// @notice sets the main destinationGauge of a token pairing
/// @param tokenA address of tokenA
/// @param tokenB address of tokenB
/// @param destinationGauge the main gauge to set to
function redirectEmissions(address tokenA, address tokenB, address destinationGauge) external;
/// @notice returns if the address is a fee distributor
/// @param _feeDistributor address of the feeDist
/// @return _trueOrFalse if the address is a fee distributor
function isFeeDistributor(address _feeDistributor) external view returns (bool _trueOrFalse);
/// @notice returns the address of the emission's token
/// @return _shadow emissions token contract address
function shadow() external view returns (address _shadow);
/// @notice returns the address of the pool's gauge, if any
/// @param _pool pool address
/// @return _gauge gauge address
function gaugeForPool(address _pool) external view returns (address _gauge);
/// @notice returns the address of the pool's feeDistributor, if any
/// @param _gauge address of the gauge
/// @return _feeDistributor address of the pool's feedist
function feeDistributorForGauge(address _gauge) external view returns (address _feeDistributor);
/// @notice returns the gauge address of a CL pool
/// @param tokenA address of token A in the pair
/// @param tokenB address of token B in the pair
/// @param tickSpacing tickspacing of the pool
/// @return gauge address of the gauge
function gaugeForClPool(address tokenA, address tokenB, int24 tickSpacing) external view returns (address gauge);
/// @notice returns the array of all tickspacings for the tokenA/tokenB combination
/// @param tokenA address of token A in the pair
/// @param tokenB address of token B in the pair
/// @return _ts array of all the tickspacings
function tickSpacingsForPair(address tokenA, address tokenB) external view returns (int24[] memory _ts);
/// @notice returns the destination of a gauge redirect
/// @param gauge address of gauge
function gaugeRedirect(address gauge) external view returns (address);
/// @notice returns the block.timestamp divided by 1 week in seconds
/// @return period the period used for gauges
function getPeriod() external view returns (uint256 period);
/// @notice cast a vote to direct emissions to gauges and earn incentives
/// @param owner address of the owner
/// @param _pools the list of pools to vote on
/// @param _weights an arbitrary weight per pool which will be normalized to 100% regardless of numerical inputs
function vote(address owner, address[] calldata _pools, uint256[] calldata _weights) external;
/// @notice reset the vote of an address
/// @param owner address of the owner
function reset(address owner) external;
/// @notice set the governor address
/// @param _governor the new governor address
function setGovernor(address _governor) external;
/// @notice recover stuck emissions
/// @param _gauge the gauge address
/// @param _period the period
function stuckEmissionsRecovery(address _gauge, uint256 _period) external;
/// @notice creates a legacy gauge for the pool
/// @param _pool pool's address
/// @return _gauge address of the new gauge
function createGauge(address _pool) external returns (address _gauge);
/// @notice create a concentrated liquidity gauge
/// @param tokenA the address of tokenA
/// @param tokenB the address of tokenB
/// @param tickSpacing the tickspacing of the pool
/// @return _clGauge address of the new gauge
function createCLGauge(address tokenA, address tokenB, int24 tickSpacing) external returns (address _clGauge);
/// @notice claim concentrated liquidity gauge rewards for specific NFP token ids
/// @param _gauges array of gauges
/// @param _tokens two dimensional array for the tokens to claim
/// @param _nfpTokenIds two dimensional array for the NFPs
function claimClGaugeRewards(
address[] calldata _gauges,
address[][] calldata _tokens,
uint256[][] calldata _nfpTokenIds
) external;
/// @notice claim arbitrary rewards from specific feeDists
/// @param owner address of the owner
/// @param _feeDistributors address of the feeDists
/// @param _tokens two dimensional array for the tokens to claim
function claimIncentives(address owner, address[] calldata _feeDistributors, address[][] calldata _tokens)
external;
/// @notice claim arbitrary rewards from specific feeDists and break up legacy pairs
/// @param owner address of the owner
/// @param _feeDistributors address of the feeDists
/// @param _tokens two dimensional array for the tokens to claim
function claimLegacyIncentives(address owner, address[] calldata _feeDistributors, address[][] calldata _tokens)
external;
/// @notice claim arbitrary rewards from specific gauges
/// @param _gauges address of the gauges
/// @param _tokens two dimensional array for the tokens to claim
function claimRewards(address[] calldata _gauges, address[][] calldata _tokens) external;
/// @notice claim arbitrary rewards from specific legacy gauges, and exit to shadow
/// @param _gauges address of the gauges
/// @param _tokens two dimensional array for the tokens to claim
function claimLegacyRewardsAndExit(address[] calldata _gauges, address[][] calldata _tokens) external;
/// @notice claim arbitrary rewards from specific cl gauges, and exit to shadow
/// @param _gauges address of the gauges
/// @param _tokens two dimensional array for the tokens to claim
/// @param _nfpTokenIds two dimensional array for the nfp to claim
function claimClGaugeRewardsAndExit(
address[] memory _gauges,
address[][] memory _tokens,
uint256[][] memory _nfpTokenIds
) external;
/// @notice distribute emissions to a gauge for a specific period
/// @param _gauge address of the gauge
/// @param _period value of the period
function distributeForPeriod(address _gauge, uint256 _period) external;
/// @notice attempt distribution of emissions to all gauges
function distributeAll() external;
/// @notice distribute emissions to gauges by index
/// @param startIndex start of the loop
/// @param endIndex end of the loop
function batchDistributeByIndex(uint256 startIndex, uint256 endIndex) external;
/// @notice lets governance update lastDistro period for a gauge
/// @dev should only be used if distribute() is running out of gas
/// @dev gaugePeriodDistributed will stop double claiming
/// @param _gauge gauge to update
/// @param _period period to update to
function updateLastDistro(address _gauge, uint256 _period) external;
/// @notice returns the votes cast for a tokenID
/// @param owner address of the owner
/// @return votes an array of votes casted
/// @return weights an array of the weights casted per pool
function getVotes(address owner, uint256 period)
external
view
returns (address[] memory votes, uint256[] memory weights);
/// @notice returns an array of all the pools
/// @return _pools the array of pools
function getAllPools() external view returns (address[] memory _pools);
/// @notice returns the length of pools
function getPoolsLength() external view returns (uint256);
/// @notice returns the pool at index
function getPool(uint256 index) external view returns (address);
/// @notice returns an array of all the gauges
/// @return _gauges the array of gauges
function getAllGauges() external view returns (address[] memory _gauges);
/// @notice returns the length of gauges
function getGaugesLength() external view returns (uint256);
/// @notice returns the gauge at index
function getGauge(uint256 index) external view returns (address);
/// @notice returns an array of all the feeDists
/// @return _feeDistributors the array of feeDists
function getAllFeeDistributors() external view returns (address[] memory _feeDistributors);
/// @notice sets the xShadowRatio default
function setGlobalRatio(uint256 _xRatio) external;
/// @notice whether the token is whitelisted in governance
function isWhitelisted(address _token) external view returns (bool _tf);
/// @notice function for removing malicious or stuffed tokens
function removeFeeDistributorReward(address _feeDist, address _token) external;
/// @notice returns the total votes for a pool in a specific period
/// @param pool the pool address to check
/// @param period the period to check
/// @return votes the total votes for the pool in that period
function poolTotalVotesPerPeriod(address pool, uint256 period) external view returns (uint256 votes);
/// @notice returns the pool address for a given gauge
/// @param gauge address of the gauge
/// @return pool address of the pool
function poolForGauge(address gauge) external view returns (address pool);
/// @notice returns the pool address for a given feeDistributor
/// @param feeDistributor address of the feeDistributor
/// @return pool address of the pool
function poolForFeeDistributor(address feeDistributor) external view returns (address pool);
/// @notice returns the voting power used by a voter for a period
/// @param user address of the user
/// @param period the period to check
function userVotingPowerPerPeriod(address user, uint256 period) external view returns (uint256 votingPower);
/// @notice returns the total votes for a specific period
/// @param period the period to check
/// @return weight the total votes for that period
function totalVotesPerPeriod(uint256 period) external view returns (uint256 weight);
/// @notice returns the total rewards allocated for a specific period
/// @param period the period to check
/// @return amount the total rewards for that period
function totalRewardPerPeriod(uint256 period) external view returns (uint256 amount);
/// @notice returns the last distribution period for a gauge
/// @param _gauge address of the gauge
/// @return period the last period distributions occurred
function lastDistro(address _gauge) external view returns (uint256 period);
/// @notice returns if the gauge is a Cl gauge
/// @param gauge the gauge to check
function isClGauge(address gauge) external view returns (bool);
/// @notice returns if the gauge is a legacy gauge
/// @param gauge the gauge to check
function isLegacyGauge(address gauge) external view returns (bool);
/// @notice sets a new NFP manager
function setNfpManager(address _nfpManager) external;
}
// SPDX-License-Identifier: GPL-2.0-or-later
pragma solidity ^0.8.0;
interface IVoteModule {
/**
* Events
*/
event Deposit(address indexed from, uint256 amount);
event Withdraw(address indexed from, uint256 amount);
event NotifyReward(address indexed from, uint256 amount);
event ClaimRewards(address indexed from, uint256 amount);
event ExemptedFromCooldown(address indexed candidate, bool status);
event NewDuration(uint256 oldDuration, uint256 newDuration);
event NewCooldown(uint256 oldCooldown, uint256 newCooldown);
event Delegate(address indexed delegator, address indexed delegatee, bool indexed isAdded);
event SetAdmin(address indexed owner, address indexed operator, bool indexed isAdded);
/**
* Functions
*/
function delegates(address) external view returns (address);
/// @notice mapping for admins for a specific address
/// @param owner the owner to check against
/// @return operator the address that is designated as an admin/operator
function admins(address owner) external view returns (address operator);
function accessHub() external view returns (address);
/// @notice reward supply for a period
function rewardSupply(uint256 period) external view returns (uint256);
/// @notice user claimed reward amount for a period
/// @dev same mapping order as FeeDistributor so the name is a bit odd
function userClaimed(uint256 period, address owner) external view returns (uint256);
/// @notice last claimed period for a user
function userLastClaimPeriod(address owner) external view returns (uint256);
/// @notice returns the current period
function getPeriod() external view returns (uint256);
/// @notice returns the amount of unclaimed rebase earned by the user
function earned(address account) external view returns (uint256 _reward);
/// @notice returns the amount of unclaimed rebase earned by the user for a period
function periodEarned(uint256 period, address user) external view returns (uint256 amount);
/// @notice the time which users can deposit and withdraw
function unlockTime() external view returns (uint256 _timestamp);
/// @notice claims pending rebase rewards
function getReward() external;
/// @notice claims pending rebase rewards for a period
function getPeriodReward(uint256 period) external;
/// @notice allows users to set their own last claimed period in case they haven't claimed in a while
/// @param period the new period to start loops from
function setUserLastClaimPeriod(uint256 period) external;
/// @notice deposits all xShadow in the caller's wallet
function depositAll() external;
/// @notice deposit a specified amount of xShadow
function deposit(uint256 amount) external;
/// @notice withdraw all xShadow
function withdrawAll() external;
/// @notice withdraw a specified amount of xShadow
function withdraw(uint256 amount) external;
/// @notice check for admin perms
/// @param operator the address to check
/// @param owner the owner to check against for permissions
function isAdminFor(address operator, address owner) external view returns (bool approved);
/// @notice check for delegations
/// @param delegate the address to check
/// @param owner the owner to check against for permissions
function isDelegateFor(address delegate, address owner) external view returns (bool approved);
/// @notice used by the xShadow contract to notify pending rebases
/// @param amount the amount of Shadow to be notified from exit penalties
function notifyRewardAmount(uint256 amount) external;
/// @notice the address of the xShadow token (staking/voting token)
/// @return _xShadow the address
function xShadow() external view returns (address _xShadow);
/// @notice address of the voter contract
/// @return _voter the voter contract address
function voter() external view returns (address _voter);
/// @notice returns the total voting power (equal to total supply in the VoteModule)
/// @return _totalSupply the total voting power
function totalSupply() external view returns (uint256 _totalSupply);
/// @notice voting power
/// @param user the address to check
/// @return amount the staked balance
function balanceOf(address user) external view returns (uint256 amount);
/// @notice delegate voting perms to another address
/// @param delegatee who you delegate to
/// @dev set address(0) to revoke
function delegate(address delegatee) external;
/// @notice give admin permissions to a another address
/// @param operator the address to give administrative perms to
/// @dev set address(0) to revoke
function setAdmin(address operator) external;
function cooldownExempt(address) external view returns (bool);
function setCooldownExemption(address, bool) external;
/// @notice lock period after rebase starts accruing
function cooldown() external returns (uint256);
function setNewCooldown(uint256) external;
}