Contract Address Details

// SPDX-License-Identifier: MIT
pragma solidity 0.8.13;
import {IVotingEscrow} from "contracts/interfaces/IVotingEscrow.sol";
import {IVoter} from "contracts/interfaces/IVoter.sol";
import {IPairFactory} from "contracts/interfaces/IPairFactory.sol";
import {IBribe} from "contracts/interfaces/IBribe.sol";
import {IERC20} from "contracts/interfaces/IERC20.sol";
import {IGauge} from "contracts/interfaces/IGauge.sol";
import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
//import {console} from "hardhat/console.sol";

/**
 * @title veClaimAllFees
 * @dev veClaimAllFees contract
 *      This contract allow users to claim all fees from all bribe contracts
 *      using a single transaction, this contract is used to subsidize the gas
 *      fees for the users that are in the auto-claim list.
 */
contract veClaimAllFees is Ownable {

    /// @dev mainnet addresses:
    IVotingEscrow public ve = IVotingEscrow(0x35361C9c2a324F5FB8f3aed2d7bA91CE1410893A);
    IVoter public voter = IVoter(0x4eB2B9768da9Ea26E3aBe605c9040bC12F236a59);
    IPairFactory public pairFactory = IPairFactory(0xA138FAFc30f6Ec6980aAd22656F2F11C38B56a95);

    /// @dev last claimed index for each token, used to continue process if we run out of gas:
    mapping(uint => uint) public lastClaimedIndex;

    /// @dev list of address in the auto-claim list, once user is added to this list
    ///      we call claimAllByTokenId() for user, so we subsidize the gas fees for the user:
    address[] public autoClaimAddresses;

    /// @dev status of each user is present in the auto-claim list:
    mapping(address => bool) public autoClaimStatus;

    /// @dev error messages:
    error NotApproved(address owner, address operator, uint tokenId);
    error InvalidTokenId(uint tokenId);
    error UserExists();
    error UserNtFound();
    error NotAuthorized();

    /// @dev list of all gauges and bribes, pre-computed to save gas, on each claim:
    address[] public gauges;
    address[] public bribes;
    uint public allPairsLength;
    uint public gaugesLength;
    uint public bribesLength;
    address[][] private rewardsByBribe;

    /// @dev max number of claims per transaction to avoid gas problem:
    uint public maxClaimPerTx = 50;

    constructor(){
        syncGauges();
        syncBribes();
    }

    /**
     * @dev used by our backend to check if we need to re-sync the list of gauges and bribes:
     */
    function needToSyncGauges() public view returns(bool){
        return allPairsLength != pairFactory.allPairsLength();
    }

    /**
     * @dev This function is called to re-sync the list of gauges and bribes,
     *      it is called from time to time from our backend to make sure
     *      we have the latest list of gauges and bribes.
     */
    function syncGauges() public {
        uint totalPools = pairFactory.allPairsLength();
        allPairsLength = totalPools;
        gauges = new address[](0);
        for (uint i = 0; i < totalPools; i++) {
            address pool = pairFactory.allPairs(i);
            address gaugeAddress = voter.gauges(pool);
            if (voter.gauges(pool) == address(0)) continue;
            gauges.push(gaugeAddress);
        }
        gaugesLength = gauges.length;
    }

    /// @dev used by our backend to check if we need to re-sync the list of bribes:
    function syncBribes() public {
        bribes = new address[](0);
        for (uint i = 0; i < gaugesLength; i++) {
            address bribeInternalAddress = IGauge(gauges[i]).internal_bribe();
            address bribeExternalAddress = IGauge(gauges[i]).external_bribe();
            if (bribeInternalAddress != address(0)){
                bribes.push(bribeInternalAddress);
            }
            if (bribeExternalAddress != address(0)){
                bribes.push(bribeExternalAddress);
            }
        }
        bribesLength = bribes.length;
    }

    /// @dev modifier to check permission on user list operations:
    modifier onlyAutoClaimAddresses( address user ) {
        if( msg.sender != user &&
            msg.sender != owner() &&
            msg.sender != ve.team() &&
            ve.isApprovedForAll(user, msg.sender) == false )
            revert NotAuthorized();
        _;
    }

    /// @dev return the list of address in the auto-claim list:
    function autoClaimAddressesLength() public view returns(uint){
        return autoClaimAddresses.length;
    }

    /// @dev return the list of address in the auto-claim list:
    function getAllUsers() public view returns(address[] memory){
        return autoClaimAddresses;
    }

    /// @dev add a new address to the auto-claim, user must need some ETH to pay for the gas:
    function addToAutoClaimAddresses(address user) public onlyAutoClaimAddresses(user) {

        if( autoClaimStatus[user] == true )
            revert UserExists();

        autoClaimStatus[user] = true;
        autoClaimAddresses.push(user);

    }

    ///
    function removeFromAutoClaimAddresses(address user) public onlyAutoClaimAddresses(user) {

        if( autoClaimStatus[user] == false )
            revert UserNtFound();

        autoClaimStatus[user] = false;

        // remove user from the array list:
        for (uint i = 0; i < autoClaimAddresses.length; i++) {
            if( autoClaimAddresses[i] == user ){
                autoClaimAddresses[i] = autoClaimAddresses[autoClaimAddresses.length - 1];
                autoClaimAddresses.pop();
                break;
            }
        }
    }

    function setMaxClaimPerTx(uint _maxClaimPerTx) public onlyOwner {
        maxClaimPerTx = _maxClaimPerTx;
    }



    /**
     * @dev claim all fees for a tokenId, this function is called from the auto-claim list,
     *      we use the lastClaimedIndex to continue the claim process if we run out of gas.
     *      Also, this function can be called by the ui too by any user.
     */
    function claimAllByTokenId(uint tokenId) public {

        address user = ve.ownerOf(tokenId);

        if( user == address(0) )
            revert InvalidTokenId(tokenId);

        if( ve.getApproved(tokenId) != address(this) &&
            ve.isApprovedForAll(user, address(this)) == false )
            revert NotApproved(user, address(this), tokenId);

        /// @dev check and reset last claimed index of this token,
        ///      this allow us to restart the claim process if we run out of gas
        if( lastClaimedIndex[tokenId] >= bribesLength - 1 )
            lastClaimedIndex[tokenId] = 0;

        uint claimed = 0;
        /// @dev reset cache:

        /// @dev claim until maxClaimPerTx:
        for (uint i = lastClaimedIndex[tokenId]; i < bribesLength; i++) {
            address bribeAddress = bribes[i];
            IBribe bribe = IBribe(bribeAddress);
            /// @dev we use storage cash as we can dynamic push to it:
            rewardsByBribe = new address[][](1);
            uint rewardsListLength = IBribe(bribe).rewardsListLength();
            for (uint j = 0; j < rewardsListLength; j++){
                address token = bribe.rewards(j);
                uint earned = bribe.earned( token, tokenId );
                if( earned == 0 ) continue;
                rewardsByBribe[0].push(token);
            }

            /// @dev check if we have any earned token on this bribe:
            if( rewardsByBribe[0].length == 0 ) continue;

            address[] memory bribeData = new address[](1);
            bribeData[0] = bribeAddress;
            voter.claimFees(bribeData, rewardsByBribe, tokenId);
            lastClaimedIndex[tokenId] = i;
            claimed++;
            if( claimed >= maxClaimPerTx ) break;
        }

    }
}
        

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.sol)

pragma solidity ^0.8.0;

import "../utils/Context.sol";

/**
 * @dev Contract module which provides a basic access control mechanism, where
 * there is an account (an owner) that can be granted exclusive access to
 * specific functions.
 *
 * By default, the owner account will be the one that deploys the contract. This
 * can later be changed with {transferOwnership}.
 *
 * This module is used through inheritance. It will make available the modifier
 * `onlyOwner`, which can be applied to your functions to restrict their use to
 * the owner.
 */
abstract contract Ownable is Context {
    address private _owner;

    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    constructor() {
        _transferOwnership(_msgSender());
    }

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        _checkOwner();
        _;
    }

    /**
     * @dev Returns the address of the current owner.
     */
    function owner() public view virtual returns (address) {
        return _owner;
    }

    /**
     * @dev Throws if the sender is not the owner.
     */
    function _checkOwner() internal view virtual {
        require(owner() == _msgSender(), "Ownable: caller is not the owner");
    }

    /**
     * @dev Leaves the contract without owner. It will not be possible to call
     * `onlyOwner` functions anymore. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby removing any functionality that is only available to the owner.
     */
    function renounceOwnership() public virtual onlyOwner {
        _transferOwnership(address(0));
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public virtual onlyOwner {
        require(newOwner != address(0), "Ownable: new owner is the zero address");
        _transferOwnership(newOwner);
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Internal function without access restriction.
     */
    function _transferOwnership(address newOwner) internal virtual {
        address oldOwner = _owner;
        _owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }
}
          

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)

pragma solidity ^0.8.0;

/**
 * @dev Provides information about the current execution context, including the
 * sender of the transaction and its data. While these are generally available
 * via msg.sender and msg.data, they should not be accessed in such a direct
 * manner, since when dealing with meta-transactions the account sending and
 * paying for execution may not be the actual sender (as far as an application
 * is concerned).
 *
 * This contract is only required for intermediate, library-like contracts.
 */
abstract contract Context {
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }

    function _msgData() internal view virtual returns (bytes calldata) {
        return msg.data;
    }
}
          

// SPDX-License-Identifier: MIT
pragma solidity 0.8.13;

interface IBribe {
    function _deposit(uint amount, uint tokenId) external;
    function _withdraw(uint amount, uint tokenId) external;
    function getRewardForOwner(uint tokenId, address[] memory tokens) external;
    function notifyRewardAmount(address token, uint amount) external;
    function left(address token) external view returns (uint);
    function rewardsListLength() external view returns (uint);
    function rewards(uint index) external view returns (address);
    function earned(address token, uint tokenId) external view returns (uint);
}
          

// SPDX-License-Identifier: MIT
pragma solidity 0.8.13;

interface IERC20 {
    function totalSupply() external view returns (uint256);
    function transfer(address recipient, uint amount) external returns (bool);
    function decimals() external view returns (uint8);
    function symbol() external view returns (string memory);
    function balanceOf(address) external view returns (uint);
    function transferFrom(address sender, address recipient, uint amount) external returns (bool);
    function allowance(address owner, address spender) external view returns (uint);
    function approve(address spender, uint value) external returns (bool);

    event Transfer(address indexed from, address indexed to, uint value);
    event Approval(address indexed owner, address indexed spender, uint value);
}
          

// SPDX-License-Identifier: MIT
pragma solidity 0.8.13;

interface IGauge {
    function notifyRewardAmount(address token, uint amount) external;
    function getReward(address account, address[] memory tokens) external;
    function claimFees() external returns (uint claimed0, uint claimed1);
    function left(address token) external view returns (uint);
    function isForPair() external view returns (bool);
    function internal_bribe() external view returns (address);
    function external_bribe() external view returns (address);
}
          

// SPDX-License-Identifier: MIT
pragma solidity 0.8.13;

interface IPairFactory {
    function allPairsLength() external view returns (uint);
    function isPair(address pair) external view returns (bool);
    function pairCodeHash() external pure returns (bytes32);
    function getPair(address tokenA, address token, bool stable) external view returns (address);
    function createPair(address tokenA, address tokenB, bool stable) external returns (address pair);
    function allPairs(uint) external view returns (address pair);
}
          

// SPDX-License-Identifier: MIT
pragma solidity 0.8.13;

interface IVoter {
    function _ve() external view returns (address);
    function governor() external view returns (address);
    function emergencyCouncil() external view returns (address);
    function attachTokenToGauge(uint _tokenId, address account) external;
    function detachTokenFromGauge(uint _tokenId, address account) external;
    function emitDeposit(uint _tokenId, address account, uint amount) external;
    function emitWithdraw(uint _tokenId, address account, uint amount) external;
    function isWhitelisted(address token) external view returns (bool);
    function notifyRewardAmount(uint amount) external;
    function distribute(address _gauge) external;
    function gauges(address _gauge) external view returns (address);
    function claimFees(address[] memory _fees, address[][] memory _tokens, uint _tokenId) external;
}
          

// SPDX-License-Identifier: MIT
pragma solidity 0.8.13;

interface IVotingEscrow {

    struct Point {
        int128 bias;
        int128 slope; // # -dweight / dt
        uint256 ts;
        uint256 blk; // block
    }

    function token() external view returns (address);
    function team() external returns (address);
    function epoch() external view returns (uint);
    function point_history(uint loc) external view returns (Point memory);
    function user_point_history(uint tokenId, uint loc) external view returns (Point memory);
    function user_point_epoch(uint tokenId) external view returns (uint);

    function ownerOf(uint) external view returns (address);
    function isApprovedOrOwner(address, uint) external view returns (bool);
    function transferFrom(address, address, uint) external;

    function voting(uint tokenId) external;
    function abstain(uint tokenId) external;
    function attach(uint tokenId) external;
    function detach(uint tokenId) external;

    function checkpoint() external;
    function deposit_for(uint tokenId, uint value) external;
    function create_lock_for(uint, uint, address) external returns (uint);

    function balanceOfNFT(uint) external view returns (uint);
    function totalSupply() external view returns (uint);
    function setApprovalForAll(address, bool) external;
    function balanceOf(address) external view returns (uint);
    function tokenOfOwnerByIndex(address, uint) external view returns (uint);
    function isApprovedForAll(address, address) external view returns (bool);
    function getApproved(uint) external view returns (address);

}
          

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.sol)

pragma solidity ^0.8.0;

import "../utils/Context.sol";

/**
 * @dev Contract module which provides a basic access control mechanism, where
 * there is an account (an owner) that can be granted exclusive access to
 * specific functions.
 *
 * By default, the owner account will be the one that deploys the contract. This
 * can later be changed with {transferOwnership}.
 *
 * This module is used through inheritance. It will make available the modifier
 * `onlyOwner`, which can be applied to your functions to restrict their use to
 * the owner.
 */
abstract contract Ownable is Context {
    address private _owner;

    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    constructor() {
        _transferOwnership(_msgSender());
    }

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        _checkOwner();
        _;
    }

    /**
     * @dev Returns the address of the current owner.
     */
    function owner() public view virtual returns (address) {
        return _owner;
    }

    /**
     * @dev Throws if the sender is not the owner.
     */
    function _checkOwner() internal view virtual {
        require(owner() == _msgSender(), "Ownable: caller is not the owner");
    }

    /**
     * @dev Leaves the contract without owner. It will not be possible to call
     * `onlyOwner` functions anymore. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby removing any functionality that is only available to the owner.
     */
    function renounceOwnership() public virtual onlyOwner {
        _transferOwnership(address(0));
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public virtual onlyOwner {
        require(newOwner != address(0), "Ownable: new owner is the zero address");
        _transferOwnership(newOwner);
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Internal function without access restriction.
     */
    function _transferOwnership(address newOwner) internal virtual {
        address oldOwner = _owner;
        _owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }
}
          

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)

pragma solidity ^0.8.0;

/**
 * @dev Provides information about the current execution context, including the
 * sender of the transaction and its data. While these are generally available
 * via msg.sender and msg.data, they should not be accessed in such a direct
 * manner, since when dealing with meta-transactions the account sending and
 * paying for execution may not be the actual sender (as far as an application
 * is concerned).
 *
 * This contract is only required for intermediate, library-like contracts.
 */
abstract contract Context {
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }

    function _msgData() internal view virtual returns (bytes calldata) {
        return msg.data;
    }
}
          

// SPDX-License-Identifier: MIT
pragma solidity 0.8.13;

interface IBribe {
    function _deposit(uint amount, uint tokenId) external;
    function _withdraw(uint amount, uint tokenId) external;
    function getRewardForOwner(uint tokenId, address[] memory tokens) external;
    function notifyRewardAmount(address token, uint amount) external;
    function left(address token) external view returns (uint);
    function rewardsListLength() external view returns (uint);
    function rewards(uint index) external view returns (address);
    function earned(address token, uint tokenId) external view returns (uint);
}
          

// SPDX-License-Identifier: MIT
pragma solidity 0.8.13;

interface IERC20 {
    function totalSupply() external view returns (uint256);
    function transfer(address recipient, uint amount) external returns (bool);
    function decimals() external view returns (uint8);
    function symbol() external view returns (string memory);
    function balanceOf(address) external view returns (uint);
    function transferFrom(address sender, address recipient, uint amount) external returns (bool);
    function allowance(address owner, address spender) external view returns (uint);
    function approve(address spender, uint value) external returns (bool);

    event Transfer(address indexed from, address indexed to, uint value);
    event Approval(address indexed owner, address indexed spender, uint value);
}
          

// SPDX-License-Identifier: MIT
pragma solidity 0.8.13;

interface IGauge {
    function notifyRewardAmount(address token, uint amount) external;
    function getReward(address account, address[] memory tokens) external;
    function claimFees() external returns (uint claimed0, uint claimed1);
    function left(address token) external view returns (uint);
    function isForPair() external view returns (bool);
    function internal_bribe() external view returns (address);
    function external_bribe() external view returns (address);
}
          

// SPDX-License-Identifier: MIT
pragma solidity 0.8.13;

interface IPairFactory {
    function allPairsLength() external view returns (uint);
    function isPair(address pair) external view returns (bool);
    function pairCodeHash() external pure returns (bytes32);
    function getPair(address tokenA, address token, bool stable) external view returns (address);
    function createPair(address tokenA, address tokenB, bool stable) external returns (address pair);
    function allPairs(uint) external view returns (address pair);
}
          

// SPDX-License-Identifier: MIT
pragma solidity 0.8.13;

interface IVoter {
    function _ve() external view returns (address);
    function governor() external view returns (address);
    function emergencyCouncil() external view returns (address);
    function attachTokenToGauge(uint _tokenId, address account) external;
    function detachTokenFromGauge(uint _tokenId, address account) external;
    function emitDeposit(uint _tokenId, address account, uint amount) external;
    function emitWithdraw(uint _tokenId, address account, uint amount) external;
    function isWhitelisted(address token) external view returns (bool);
    function notifyRewardAmount(uint amount) external;
    function distribute(address _gauge) external;
    function gauges(address _gauge) external view returns (address);
    function claimFees(address[] memory _fees, address[][] memory _tokens, uint _tokenId) external;
}
          

// SPDX-License-Identifier: MIT
pragma solidity 0.8.13;

interface IVotingEscrow {

    struct Point {
        int128 bias;
        int128 slope; // # -dweight / dt
        uint256 ts;
        uint256 blk; // block
    }

    function token() external view returns (address);
    function team() external returns (address);
    function epoch() external view returns (uint);
    function point_history(uint loc) external view returns (Point memory);
    function user_point_history(uint tokenId, uint loc) external view returns (Point memory);
    function user_point_epoch(uint tokenId) external view returns (uint);

    function ownerOf(uint) external view returns (address);
    function isApprovedOrOwner(address, uint) external view returns (bool);
    function transferFrom(address, address, uint) external;

    function voting(uint tokenId) external;
    function abstain(uint tokenId) external;
    function attach(uint tokenId) external;
    function detach(uint tokenId) external;

    function checkpoint() external;
    function deposit_for(uint tokenId, uint value) external;
    function create_lock_for(uint, uint, address) external returns (uint);

    function balanceOfNFT(uint) external view returns (uint);
    function totalSupply() external view returns (uint);
    function setApprovalForAll(address, bool) external;
    function balanceOf(address) external view returns (uint);
    function tokenOfOwnerByIndex(address, uint) external view returns (uint);
    function isApprovedForAll(address, address) external view returns (bool);
    function getApproved(uint) external view returns (address);

}