Contract Source Code (Solidity Multiple files format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

// SPDX-License-Identifier: GNU AGPLv3
pragma solidity ^0.8.22;

import {WeekStart, IYearnBoostedStaker} from "./WeekStart.sol";
import {IERC20, SafeERC20} from "./SafeERC20.sol";


contract SingleTokenRewardDistributor is WeekStart {
    using SafeERC20 for IERC20;

    uint constant public PRECISION = 1e27;
    IYearnBoostedStaker public immutable staker;
    IERC20 public immutable rewardToken;
    uint public immutable START_WEEK;
    uint immutable MAX_STAKE_GROWTH_WEEKS;

    struct AccountInfo {
        address recipient; // Who rewards will be sent to. Cheaper to store here than in dedicated mapping.
        uint96 lastClaimWeek;
    }

    mapping(uint week => uint amount) public weeklyRewardAmount;
    mapping(address account => AccountInfo info) public accountInfo;
    mapping(address account => mapping(address claimer => bool approved)) public approvedClaimer;
    
    event RewardDeposited(uint indexed week, address indexed depositor, uint rewardAmount);
    event RewardsClaimed(address indexed account, uint indexed week, uint rewardAmount);
    event RecipientConfigured(address indexed account, address indexed recipient);
    event ClaimerApproved(address indexed account, address indexed, bool approved);
    event RewardPushed(uint indexed fromWeek, uint indexed toWeek, uint amount);

    /**
        @param _staker the staking contract to use for weight calculations.
        @param _rewardToken address of reward token to be used.
    */
    constructor(
        IYearnBoostedStaker _staker,
        IERC20 _rewardToken
    )
        WeekStart(_staker) {
        staker = _staker;
        rewardToken = _rewardToken;
        START_WEEK = staker.getWeek();
        MAX_STAKE_GROWTH_WEEKS = staker.MAX_STAKE_GROWTH_WEEKS();
    }

    /**
        @notice Allow permissionless deposits to the current week.
        @param _amount the amount of reward token to deposit.
    */
    function depositReward(uint _amount) external {
        if (_amount > 0) {
            uint week = getWeek();
            weeklyRewardAmount[week] += _amount;
            rewardToken.safeTransferFrom(msg.sender, address(this), _amount);
            emit RewardDeposited(week, msg.sender, _amount);
        }
    }

    /**
        @notice Push inaccessible rewards to current week.
        @dev    In rare circumstances, rewards may have been deposited to a week where no adjusted weight exists.
                This function allows us to recover rewards to the current week.
        @param _week the week to push rewards from.
        @return true if operation was successful.
    */
    function pushRewards(uint _week) external returns (bool) {
        uint week = getWeek();
        uint amount = pushableRewards(_week);
        if(amount == 0) return false;
        weeklyRewardAmount[_week] = 0;
        weeklyRewardAmount[week] += amount;
        emit RewardPushed(_week, week, amount);
        return true;
    }

    /**
        @notice Helper view function to check if any rewards are pushable.
        @param _week the week to push rewards from.
        @return uint representing rewards amount that is pushable.
    */
    function pushableRewards(uint _week) public view returns (uint) {
        uint week = getWeek();
        if(_week >= week) return 0;
        if(adjustedGlobalWeightAt(_week) != 0) return 0;
        return weeklyRewardAmount[_week];
    }

    /**
        @notice Claim all owed rewards since the last week touched by the user.
        @dev    It is not suggested to use this function directly. Rather `claimWithRange` 
                will tend to be more gas efficient when used with values from `getSuggestedClaimRange`.
    */
    function claim() external returns (uint amountClaimed) {
        uint currentWeek = getWeek();
        currentWeek = currentWeek == 0 ? 0 : currentWeek - 1;
        return _claimWithRange(msg.sender, 0, currentWeek);
    }

    /**
        @notice Claim on behalf of another account. Retrieves all owed rewards since the last week touched by the user.
        @dev    It is not suggested to use this function directly. Rather `claimWithRange` 
                will tend to be more gas efficient when used with values from `getSuggestedClaimRange`.
    */
    function claimFor(address _account) external returns (uint amountClaimed) {
        require(_onlyClaimers(_account), "!approvedClaimer");
        uint currentWeek = getWeek();
        currentWeek = currentWeek == 0 ? 0 : currentWeek - 1;
        return _claimWithRange(_account, 0, currentWeek);
    }

    /**
        @notice Claim rewards within a range of specified past weeks.
        @param _claimStartWeek the min week to search and rewards.
        @param _claimEndWeek the max week in which to search for and claim rewards.
        @dev    IMPORTANT: Choosing a `_claimStartWeek` that is greater than the earliest week in which a user
                may claim. Will result in the user being locked out (total loss) of rewards for any weeks prior.
    */
    function claimWithRange(
        uint _claimStartWeek,
        uint _claimEndWeek
    ) external returns (uint amountClaimed) {
        return _claimWithRange(msg.sender, _claimStartWeek, _claimEndWeek);
    }

    /**
        @notice Claim on behalf of another account for a range of specified past weeks.
        @param _account Account of which to make the claim on behalf of.
        @param _claimStartWeek The min week to search and rewards.
        @param _claimEndWeek The max week in which to search for and claim rewards.
        @dev    WARNING: Choosing a `_claimStartWeek` that is greater than the earliest week in which a user
                may claim will result in the user being locked out (total loss) of rewards for any weeks prior.
        @dev    Useful to target specific weeks with known reward amounts. Claiming via this function will tend 
                to be more gas efficient when used with values from `getSuggestedClaimRange`.
    */
    function claimWithRangeFor(
        address _account,
        uint _claimStartWeek,
        uint _claimEndWeek
    ) external returns (uint amountClaimed) {
        require(_onlyClaimers(_account), "!approvedClaimer");
        return _claimWithRange(_account, _claimStartWeek, _claimEndWeek);
    }

    function _claimWithRange(
        address _account,
        uint _claimStartWeek,
        uint _claimEndWeek
    ) internal returns (uint amountClaimed) {
        uint currentWeek = getWeek();
        if(_claimEndWeek >= currentWeek) return 0;

        AccountInfo storage info = accountInfo[_account];
        
        // Sanitize inputs
        uint _minStartWeek = info.lastClaimWeek == 0 ? START_WEEK : info.lastClaimWeek;
        _claimStartWeek = max(_minStartWeek, _claimStartWeek);
        if(_claimStartWeek > _claimEndWeek) return 0;
        
        amountClaimed = _getTotalClaimableByRange(_account, _claimStartWeek, _claimEndWeek);
        
        _claimEndWeek += 1;
        info.lastClaimWeek = uint96(_claimEndWeek);
        
        if (amountClaimed > 0) {
            address recipient = info.recipient == address(0) ? _account : info.recipient;
            rewardToken.safeTransfer(recipient, amountClaimed);
            emit RewardsClaimed(_account, _claimEndWeek, amountClaimed);
        }
    }

    /**
        @notice Helper function used to determine overall share of rewards at a particular week.
        @dev    IMPORTANT: This calculation cannot be relied upon to return strictly the users weight
                against global weight as it implements custom logic to ignore the first week of each deposit.
        @dev    Computing shares in past weeks is accurate. However, current week computations will not 
                be accurate until week is finalized.
        @dev    Results scaled to PRECSION.
    */
    function computeSharesAt(address _account, uint _week) public view returns (uint) {
        require(_week <= getWeek(), "Invalid week");
        // As a security measure, we don't distribute rewards to YBS deposits on their first full week of staking.
        // To acheive this, we lookup the weight that was added in the target week and ignore it.
        uint adjAcctWeight = adjustedAccountWeightAt(_account, _week);
        if (adjAcctWeight == 0) return 0;
        
        uint adjGlobalWeight = adjustedGlobalWeightAt(_week);
        if (adjGlobalWeight == 0) return 0;

        return adjAcctWeight * PRECISION / adjGlobalWeight;
    }

    function adjustedAccountWeightAt(address _account, uint _week) public view returns (uint) {
        uint acctWeight = staker.getAccountWeightAt(_account, _week);
        if (acctWeight == 0) return 0;
        return acctWeight - staker.accountWeeklyToRealize(_account, _week + MAX_STAKE_GROWTH_WEEKS).weightPersistent;
    }

    function adjustedGlobalWeightAt(uint _week) public view returns (uint) {
        uint globalWeight = staker.getGlobalWeightAt(_week);
        if (globalWeight == 0) return 0;
        return globalWeight - staker.globalWeeklyToRealize(_week + MAX_STAKE_GROWTH_WEEKS).weightPersistent;
    }

    /**
        @notice Get the sum total number of claimable tokens for a user across all his claimable weeks.
    */
    function getClaimable(address _account) external view returns (uint claimable) {
        (uint claimStartWeek, uint claimEndWeek) = getSuggestedClaimRange(_account);
        return _getTotalClaimableByRange(_account, claimStartWeek, claimEndWeek);
    }

    /**
        @notice Returns sum of tokens earned with a specified range of weeks.
        @param _account Account to query.
        @param _claimStartWeek Week to begin querying from.
        @param _claimEndWeek Week to end querying at.
    */
    function getTotalClaimableByRange(
        address _account,
        uint _claimStartWeek,
        uint _claimEndWeek
    ) external view returns (uint claimable) {
        uint currentWeek = getWeek();
        if (_claimEndWeek >= currentWeek) _claimEndWeek = currentWeek - 1;
        return _getTotalClaimableByRange(_account, _claimStartWeek, _claimEndWeek);
    }

    function _getTotalClaimableByRange(
        address _account,
        uint _claimStartWeek,
        uint _claimEndWeek
    ) internal view returns (uint claimableAmount) {
        for (uint i = _claimStartWeek; i <= _claimEndWeek; ++i) {
            claimableAmount += _getClaimableAt(_account, i);
        }
    }

    /**
        @notice Helper function returns suggested start and end range for claim weeks.
        @dev    This function is designed to be called prior to ranged claims to shorten the number of iterations
                required to loop if possible.
    */
    function getSuggestedClaimRange(address _account) public view returns (uint claimStartWeek, uint claimEndWeek) {
        uint currentWeek = getWeek();
        if (currentWeek == 0) return (0, 0);
        bool canClaim;
        uint lastClaimWeek = accountInfo[_account].lastClaimWeek;
        
        claimStartWeek = START_WEEK > lastClaimWeek ? START_WEEK : lastClaimWeek;

        // Loop from old towards recent.
        for (claimStartWeek; claimStartWeek <= currentWeek; claimStartWeek++) {
            if (_getClaimableAt(_account, claimStartWeek) > 0) {
                canClaim = true;
                break;
            }
        }

        if (!canClaim) return (0,0);

        // Loop backwards from recent week towards old. Skip current week.
        for (claimEndWeek = currentWeek - 1; claimEndWeek > claimStartWeek; claimEndWeek--) {
            if (_getClaimableAt(_account, claimEndWeek) > 0) {
                break;
            }
        }

        return (claimStartWeek, claimEndWeek);
    }

    /**
        @notice Get the reward amount available at a given week index.
        @param _account The account to check.
        @param _week The past week to check.
    */
    function getClaimableAt(
        address _account, 
        uint _week
    ) external view returns (uint rewardAmount) {
        if(_week >= getWeek()) return 0;
        return _getClaimableAt(_account, _week);
    }

    function _getClaimableAt(
        address _account, 
        uint _week
    ) internal view returns (uint rewardAmount) {
        if(_week < accountInfo[_account].lastClaimWeek) return 0;
        uint rewardShare = computeSharesAt(_account, _week);
        uint totalWeeklyAmount = weeklyRewardAmount[_week];
        rewardAmount = rewardShare * totalWeeklyAmount / PRECISION;
    }

    function _onlyClaimers(address _account) internal view returns (bool approved) {
        return approvedClaimer[_account][msg.sender] || _account == msg.sender;
    }

    /**
        @notice User may configure their account to set a custom reward recipient.
        @param _recipient   Wallet to receive rewards on behalf of the account. Zero address will result in all 
                            rewards being transferred directly to the account holder.
    */
    function configureRecipient(address _recipient) external {
        accountInfo[msg.sender].recipient = _recipient;
        emit RecipientConfigured(msg.sender, _recipient);
    }

    /**
        @notice Allow account to specify addresses to claim on their behalf.
        @param _claimer Claimer to approve or revoke
        @param _approved True to approve, False to revoke.
    */
    function approveClaimer(address _claimer, bool _approved) external {
        approvedClaimer[msg.sender][_claimer] = _approved;
        emit ClaimerApproved(msg.sender, _claimer, _approved);
    }

    function max(uint a, uint b) internal pure returns (uint) {
        return a < b ? b : a;
    }
}

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

pragma solidity ^0.8.1;

/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev Returns true if `account` is a contract.
     *
     * [IMPORTANT]
     * ====
     * It is unsafe to assume that an address for which this function returns
     * false is an externally-owned account (EOA) and not a contract.
     *
     * Among others, `isContract` will return false for the following
     * types of addresses:
     *
     *  - an externally-owned account
     *  - a contract in construction
     *  - an address where a contract will be created
     *  - an address where a contract lived, but was destroyed
     * ====
     *
     * [IMPORTANT]
     * ====
     * You shouldn't rely on `isContract` to protect against flash loan attacks!
     *
     * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets
     * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract
     * constructor.
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize/address.code.length, which returns 0
        // for contracts in construction, since the code is only stored at the end
        // of the constructor execution.

        return account.code.length > 0;
    }

    /**
     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to
     * `recipient`, forwarding all available gas and reverting on errors.
     *
     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
     * of certain opcodes, possibly making contracts go over the 2300 gas limit
     * imposed by `transfer`, making them unable to receive funds via
     * `transfer`. {sendValue} removes this limitation.
     *
     * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
     *
     * IMPORTANT: because control is transferred to `recipient`, care must be
     * taken to not create reentrancy vulnerabilities. Consider using
     * {ReentrancyGuard} or the
     * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
     */
    function sendValue(address payable recipient, uint256 amount) internal {
        require(address(this).balance >= amount, "Address: insufficient balance");

        (bool success, ) = recipient.call{value: amount}("");
        require(success, "Address: unable to send value, recipient may have reverted");
    }

    /**
     * @dev Performs a Solidity function call using a low level `call`. A
     * plain `call` is an unsafe replacement for a function call: use this
     * function instead.
     *
     * If `target` reverts with a revert reason, it is bubbled up by this
     * function (like regular Solidity function calls).
     *
     * Returns the raw returned data. To convert to the expected return value,
     * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
     *
     * Requirements:
     *
     * - `target` must be a contract.
     * - calling `target` with `data` must not revert.
     *
     * _Available since v3.1._
     */
    function functionCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0, "Address: low-level call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
     * `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but also transferring `value` wei to `target`.
     *
     * Requirements:
     *
     * - the calling contract must have an ETH balance of at least `value`.
     * - the called Solidity function must be `payable`.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(
        address target,
        bytes memory data,
        uint256 value
    ) internal returns (bytes memory) {
        return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
    }

    /**
     * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
     * with `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(
        address target,
        bytes memory data,
        uint256 value,
        string memory errorMessage
    ) internal returns (bytes memory) {
        require(address(this).balance >= value, "Address: insufficient balance for call");
        (bool success, bytes memory returndata) = target.call{value: value}(data);
        return verifyCallResultFromTarget(target, success, returndata, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
        return functionStaticCall(target, data, "Address: low-level static call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal view returns (bytes memory) {
        (bool success, bytes memory returndata) = target.staticcall(data);
        return verifyCallResultFromTarget(target, success, returndata, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionDelegateCall(target, data, "Address: low-level delegate call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal returns (bytes memory) {
        (bool success, bytes memory returndata) = target.delegatecall(data);
        return verifyCallResultFromTarget(target, success, returndata, errorMessage);
    }

    /**
     * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling
     * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract.
     *
     * _Available since v4.8._
     */
    function verifyCallResultFromTarget(
        address target,
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal view returns (bytes memory) {
        if (success) {
            if (returndata.length == 0) {
                // only check isContract if the call was successful and the return data is empty
                // otherwise we already know that it was a contract
                require(isContract(target), "Address: call to non-contract");
            }
            return returndata;
        } else {
            _revert(returndata, errorMessage);
        }
    }

    /**
     * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the
     * revert reason or using the provided one.
     *
     * _Available since v4.3._
     */
    function verifyCallResult(
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal pure returns (bytes memory) {
        if (success) {
            return returndata;
        } else {
            _revert(returndata, errorMessage);
        }
    }

    function _revert(bytes memory returndata, string memory errorMessage) private pure {
        // Look for revert reason and bubble it up if present
        if (returndata.length > 0) {
            // The easiest way to bubble the revert reason is using memory via assembly
            /// @solidity memory-safe-assembly
            assembly {
                let returndata_size := mload(returndata)
                revert(add(32, returndata), returndata_size)
            }
        } else {
            revert(errorMessage);
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/IERC20.sol)

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
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 amount of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns the amount of tokens owned by `account`.
     */
    function balanceOf(address account) external view returns (uint256);

    /**
     * @dev Moves `amount` 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 amount) 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 `amount` 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 amount) external returns (bool);

    /**
     * @dev Moves `amount` tokens from `from` to `to` using the
     * allowance mechanism. `amount` 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 amount) external returns (bool);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/extensions/IERC20Permit.sol)

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in
 * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].
 *
 * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by
 * presenting a message signed by the account. By not relying on {IERC20-approve}, the token holder account doesn't
 * need to send a transaction, and thus is not required to hold Ether at all.
 */
interface IERC20Permit {
    /**
     * @dev Sets `value` as the allowance of `spender` over ``owner``'s tokens,
     * given ``owner``'s signed approval.
     *
     * IMPORTANT: The same issues {IERC20-approve} has related to transaction
     * ordering also apply here.
     *
     * Emits an {Approval} event.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     * - `deadline` must be a timestamp in the future.
     * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`
     * over the EIP712-formatted function arguments.
     * - the signature must use ``owner``'s current nonce (see {nonces}).
     *
     * For more information on the signature format, see the
     * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP
     * section].
     */
    function permit(
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external;

    /**
     * @dev Returns the current nonce for `owner`. This value must be
     * included whenever a signature is generated for {permit}.
     *
     * Every successful call to {permit} increases ``owner``'s nonce by one. This
     * prevents a signature from being used multiple times.
     */
    function nonces(address owner) external view returns (uint256);

    /**
     * @dev Returns the domain separator used in the encoding of the signature for {permit}, as defined by {EIP712}.
     */
    // solhint-disable-next-line func-name-mixedcase
    function DOMAIN_SEPARATOR() external view returns (bytes32);
}

// SPDX-License-Identifier: AGPL-3.0
pragma solidity ^0.8.22;

import {IERC20, SafeERC20} from "./SafeERC20.sol";

interface IYearnBoostedStaker {
    struct AccountData {
        uint112 realizedStake;
        uint112 pendingStake;
        uint16 lastUpdateWeek;
        uint8 updateWeeksBitmap;
    }

    struct ToRealize {
        uint112 weightPersistent;
        uint112 weight;
    }

    enum ApprovalStatus {
        None,
        StakeOnly,
        UnstakeOnly,
        StakeAndUnstake
    }

    // State variables
    function MAX_STAKE_GROWTH_WEEKS() external view returns (uint);
    function MAX_WEEK_BIT() external view returns (uint8);
    function START_TIME() external view returns (uint);
    function stakeToken() external view returns (IERC20);
    function globalGrowthRate() external view returns (uint112);
    function globalLastUpdateWeek() external view returns (uint16);
    function totalSupply() external view returns (uint);
    function decimals() external view returns (uint8);
    function owner() external view returns (address);
    function pendingOwner() external view returns (address);
    function approvedCaller(address account, address caller) external view returns (ApprovalStatus);
    function approvedWeightedStaker(address staker) external view returns (bool);
    function accountWeeklyToRealize(address account, uint week) external view returns (ToRealize memory);
    function globalWeeklyToRealize(uint week) external view returns (ToRealize memory);
    function accountWeeklyMaxStake(address account, uint week) external view returns (uint);
    function globalWeeklyMaxStake(uint week) external view returns (uint);

    // Events
    event Stake(address indexed account, uint indexed week, uint amount, uint newUserWeight, uint weightAdded);
    event Unstake(address indexed account, uint indexed week, uint amount, uint newUserWeight, uint weightRemoved);
    event ApprovedCallerSet(address indexed account, address indexed caller, ApprovalStatus status);
    event WeightedStakerSet(address indexed staker, bool approved);
    event OwnershipTransferred(address indexed newOwner);

    // Functions
    function stake(uint _amount) external returns (uint);
    function stakeFor(address _account, uint _amount) external returns (uint);
    function stakeAsMaxWeighted(address _account, uint _amount) external returns (uint);
    function unstake(uint _amount, address _receiver) external returns (uint);
    function unstakeFor(address _account, uint _amount, address _receiver) external returns (uint);

    function checkpointAccount(address _account) external returns (AccountData memory acctData, uint weight);
    function checkpointAccountWithLimit(address _account, uint _week) external returns (AccountData memory acctData, uint weight);

    function getAccountWeight(address account) external view returns (uint);
    function getAccountWeightAt(address _account, uint _week) external view returns (uint);

    function checkpointGlobal() external returns (uint);
    function getGlobalWeight() external view returns (uint);
    function getGlobalWeightAt(uint week) external view returns (uint);

    function getAccountWeightRatio(address _account) external view returns (uint);
    function getAccountWeightRatioAt(address _account, uint _week) external view returns (uint);

    function balanceOf(address _account) external view returns (uint);
    function setApprovedCaller(address _caller, ApprovalStatus _status) external;
    function setWeightedStaker(address _staker, bool _approved) external;

    function transferOwnership(address _pendingOwner) external;
    function acceptOwnership() external;

    function sweep(address _token) external;
    function getWeek() external view returns (uint);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.3) (token/ERC20/utils/SafeERC20.sol)

pragma solidity ^0.8.0;

import "./IERC20.sol";
import "./IERC20Permit.sol";
import "./Address.sol";

/**
 * @title SafeERC20
 * @dev Wrappers around ERC20 operations that throw on failure (when the token
 * contract returns false). Tokens that return no value (and instead revert or
 * throw on failure) are also supported, non-reverting calls are assumed to be
 * successful.
 * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,
 * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
 */
library SafeERC20 {
    using Address for address;

    /**
     * @dev Transfer `value` amount of `token` from the calling contract to `to`. If `token` returns no value,
     * non-reverting calls are assumed to be successful.
     */
    function safeTransfer(IERC20 token, address to, uint256 value) internal {
        _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
    }

    /**
     * @dev Transfer `value` amount of `token` from `from` to `to`, spending the approval given by `from` to the
     * calling contract. If `token` returns no value, non-reverting calls are assumed to be successful.
     */
    function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
        _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
    }

    /**
     * @dev Deprecated. This function has issues similar to the ones found in
     * {IERC20-approve}, and its usage is discouraged.
     *
     * Whenever possible, use {safeIncreaseAllowance} and
     * {safeDecreaseAllowance} instead.
     */
    function safeApprove(IERC20 token, address spender, uint256 value) internal {
        // safeApprove should only be called when setting an initial allowance,
        // or when resetting it to zero. To increase and decrease it, use
        // 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
        require(
            (value == 0) || (token.allowance(address(this), spender) == 0),
            "SafeERC20: approve from non-zero to non-zero allowance"
        );
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
    }

    /**
     * @dev Increase the calling contract's allowance toward `spender` by `value`. If `token` returns no value,
     * non-reverting calls are assumed to be successful.
     */
    function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
        uint256 oldAllowance = token.allowance(address(this), spender);
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, oldAllowance + value));
    }

    /**
     * @dev Decrease the calling contract's allowance toward `spender` by `value`. If `token` returns no value,
     * non-reverting calls are assumed to be successful.
     */
    function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
        unchecked {
            uint256 oldAllowance = token.allowance(address(this), spender);
            require(oldAllowance >= value, "SafeERC20: decreased allowance below zero");
            _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, oldAllowance - value));
        }
    }

    /**
     * @dev Set the calling contract's allowance toward `spender` to `value`. If `token` returns no value,
     * non-reverting calls are assumed to be successful. Meant to be used with tokens that require the approval
     * to be set to zero before setting it to a non-zero value, such as USDT.
     */
    function forceApprove(IERC20 token, address spender, uint256 value) internal {
        bytes memory approvalCall = abi.encodeWithSelector(token.approve.selector, spender, value);

        if (!_callOptionalReturnBool(token, approvalCall)) {
            _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, 0));
            _callOptionalReturn(token, approvalCall);
        }
    }

    /**
     * @dev Use a ERC-2612 signature to set the `owner` approval toward `spender` on `token`.
     * Revert on invalid signature.
     */
    function safePermit(
        IERC20Permit token,
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) internal {
        uint256 nonceBefore = token.nonces(owner);
        token.permit(owner, spender, value, deadline, v, r, s);
        uint256 nonceAfter = token.nonces(owner);
        require(nonceAfter == nonceBefore + 1, "SafeERC20: permit did not succeed");
    }

    /**
     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
     * on the return value: the return value is optional (but if data is returned, it must not be false).
     * @param token The token targeted by the call.
     * @param data The call data (encoded using abi.encode or one of its variants).
     */
    function _callOptionalReturn(IERC20 token, bytes memory data) private {
        // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
        // we're implementing it ourselves. We use {Address-functionCall} to perform this call, which verifies that
        // the target address contains contract code and also asserts for success in the low-level call.

        bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
        require(returndata.length == 0 || abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
    }

    /**
     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
     * on the return value: the return value is optional (but if data is returned, it must not be false).
     * @param token The token targeted by the call.
     * @param data The call data (encoded using abi.encode or one of its variants).
     *
     * This is a variant of {_callOptionalReturn} that silents catches all reverts and returns a bool instead.
     */
    function _callOptionalReturnBool(IERC20 token, bytes memory data) private returns (bool) {
        // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
        // we're implementing it ourselves. We cannot use {Address-functionCall} here since this should return false
        // and not revert is the subcall reverts.

        (bool success, bytes memory returndata) = address(token).call(data);
        return
            success && (returndata.length == 0 || abi.decode(returndata, (bool))) && Address.isContract(address(token));
    }
}

// SPDX-License-Identifier: GNU AGPLv3
pragma solidity ^0.8.22;
import {IYearnBoostedStaker} from "./IYearnBoostedStaker.sol";

/**
    @title Week Start
    @dev Provides a unified `START_TIME` and `getWeek` aligned with the staker.
 */
contract WeekStart {
    uint256 public immutable START_TIME;

    constructor(IYearnBoostedStaker staker) {
        START_TIME = staker.START_TIME();
    }

    function getWeek() public view returns (uint256 week) {
        return (block.timestamp - START_TIME) / 1 weeks;
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"contract IYearnBoostedStaker","name":"_staker","type":"address"},{"internalType":"contract IERC20","name":"_rewardToken","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"address","name":"","type":"address"},{"indexed":false,"internalType":"bool","name":"approved","type":"bool"}],"name":"ClaimerApproved","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"address","name":"recipient","type":"address"}],"name":"RecipientConfigured","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"week","type":"uint256"},{"indexed":true,"internalType":"address","name":"depositor","type":"address"},{"indexed":false,"internalType":"uint256","name":"rewardAmount","type":"uint256"}],"name":"RewardDeposited","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"fromWeek","type":"uint256"},{"indexed":true,"internalType":"uint256","name":"toWeek","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"RewardPushed","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"uint256","name":"week","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"rewardAmount","type":"uint256"}],"name":"RewardsClaimed","type":"event"},{"inputs":[],"name":"PRECISION","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"START_TIME","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"START_WEEK","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"accountInfo","outputs":[{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint96","name":"lastClaimWeek","type":"uint96"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_account","type":"address"},{"internalType":"uint256","name":"_week","type":"uint256"}],"name":"adjustedAccountWeightAt","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_week","type":"uint256"}],"name":"adjustedGlobalWeightAt","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_claimer","type":"address"},{"internalType":"bool","name":"_approved","type":"bool"}],"name":"approveClaimer","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"address","name":"claimer","type":"address"}],"name":"approvedClaimer","outputs":[{"internalType":"bool","name":"approved","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"claim","outputs":[{"internalType":"uint256","name":"amountClaimed","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_account","type":"address"}],"name":"claimFor","outputs":[{"internalType":"uint256","name":"amountClaimed","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_claimStartWeek","type":"uint256"},{"internalType":"uint256","name":"_claimEndWeek","type":"uint256"}],"name":"claimWithRange","outputs":[{"internalType":"uint256","name":"amountClaimed","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_account","type":"address"},{"internalType":"uint256","name":"_claimStartWeek","type":"uint256"},{"internalType":"uint256","name":"_claimEndWeek","type":"uint256"}],"name":"claimWithRangeFor","outputs":[{"internalType":"uint256","name":"amountClaimed","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_account","type":"address"},{"internalType":"uint256","name":"_week","type":"uint256"}],"name":"computeSharesAt","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_recipient","type":"address"}],"name":"configureRecipient","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"depositReward","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_account","type":"address"}],"name":"getClaimable","outputs":[{"internalType":"uint256","name":"claimable","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_account","type":"address"},{"internalType":"uint256","name":"_week","type":"uint256"}],"name":"getClaimableAt","outputs":[{"internalType":"uint256","name":"rewardAmount","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_account","type":"address"}],"name":"getSuggestedClaimRange","outputs":[{"internalType":"uint256","name":"claimStartWeek","type":"uint256"},{"internalType":"uint256","name":"claimEndWeek","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_account","type":"address"},{"internalType":"uint256","name":"_claimStartWeek","type":"uint256"},{"internalType":"uint256","name":"_claimEndWeek","type":"uint256"}],"name":"getTotalClaimableByRange","outputs":[{"internalType":"uint256","name":"claimable","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getWeek","outputs":[{"internalType":"uint256","name":"week","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_week","type":"uint256"}],"name":"pushRewards","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_week","type":"uint256"}],"name":"pushableRewards","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"rewardToken","outputs":[{"internalType":"contract IERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"staker","outputs":[{"internalType":"contract IYearnBoostedStaker","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"week","type":"uint256"}],"name":"weeklyRewardAmount","outputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"stateMutability":"view","type":"function"}]

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

182:13472:5:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;405:32;;;;;;;;160:25:7;;;148:2;133:18;405:32:5;;;;;;;;1914:313;;;;;;:::i;:::-;;:::i;:::-;;657:59;;;;;;:::i;:::-;;;;;;;;;;;;;;;791:92;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;989:14:7;;982:22;964:41;;952:2;937:18;791:92:5;824:187:7;8814:289:5;;;;;;:::i;:::-;;:::i;5979:298::-;;;;;;:::i;:::-;;:::i;3683:222::-;;;:::i;315:43::-;;;;;;;;-1:-1:-1;;;;;1534:32:7;;;1516:51;;1504:2;1489:18;315:43:5;1343:230:7;7834:644:5;;;;;;:::i;:::-;;:::i;9736:367::-;;;;;;:::i;:::-;;:::i;13355:196::-;;;;;;:::i;:::-;;:::i;8484:324::-;;;;;;:::i;:::-;;:::i;10691:1014::-;;;;;;:::i;:::-;;:::i;:::-;;;;2645:25:7;;;2701:2;2686:18;;2679:34;;;;2618:18;10691:1014:5;2471:248:7;400:118:6;;;:::i;3149:237:5:-;;;;;;:::i;:::-;;:::i;5009:209::-;;;;;;:::i;:::-;;:::i;9228:253::-;;;;;;:::i;:::-;;:::i;722:63::-;;;;;;:::i;:::-;;;;;;;;;;;;-1:-1:-1;;;;;722:63:5;;;-1:-1:-1;;;722:63:5;;-1:-1:-1;;;;;722:63:5;;;;;;;-1:-1:-1;;;;;3167:32:7;;;3149:51;;-1:-1:-1;;;;;3236:39:7;;;3231:2;3216:18;;3209:67;3122:18;722:63:5;2977:305:7;272:37:5;;305:4;272:37;;11888:216;;;;;;:::i;:::-;;:::i;12967:178::-;;;;;;:::i;:::-;;:::i;2603:331::-;;;;;;:::i;:::-;;:::i;263:35:6:-;;;;;4242:301:5;;;;;;:::i;:::-;;:::i;364:35::-;;;;;1914:313;1974:11;;1970:251;;2001:9;2013;:7;:9::i;:::-;2001:21;;2064:7;2036:18;:24;2055:4;2036:24;;;;;;;;;;;;:35;;;;;;;:::i;:::-;;;;-1:-1:-1;2085:64:5;;-1:-1:-1;;;;;;2085:11:5;:28;2114:10;2134:4;2141:7;2085:28;:64::i;:::-;2168:42;;160:25:7;;;2190:10:5;;2184:4;;2168:42;;148:2:7;133:18;2168:42:5;;;;;;;;1987:234;1970:251;1914:313;:::o;8814:289::-;8915:31;;-1:-1:-1;;;8915:31:5;;;;;160:25:7;;;8879:4:5;;;;-1:-1:-1;;;;;8915:6:5;:24;;;;133:18:7;;8915:31:5;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;8895:51;;8960:12;8976:1;8960:17;8956:31;;-1:-1:-1;8986:1:5;;8814:289;-1:-1:-1;;8814:289:5:o;8956:31::-;-1:-1:-1;;;;;9019:6:5;:28;;9048:30;9056:22;9048:5;:30;:::i;:::-;9019:60;;;;;;;;;;;;;160:25:7;;148:2;133:18;;14:177;9019:60:5;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:77;9004:92;;-1:-1:-1;;;;;9004:92:5;:12;:92;:::i;:::-;8997:99;8814:289;-1:-1:-1;;;8814:289:5:o;5979:298::-;6114:18;6152:23;6166:8;6152:13;:23::i;:::-;6144:52;;;;-1:-1:-1;;;6144:52:5;;5140:2:7;6144:52:5;;;5122:21:7;5179:2;5159:18;;;5152:30;-1:-1:-1;;;5198:18:7;;;5191:46;5254:18;;6144:52:5;;;;;;;;;6213:57;6229:8;6239:15;6256:13;6213:15;:57::i;:::-;6206:64;5979:298;-1:-1:-1;;;;5979:298:5:o;3683:222::-;3718:18;3748:16;3767:9;:7;:9::i;:::-;3748:28;-1:-1:-1;3800:16:5;;:38;;3823:15;3837:1;3823:11;:15;:::i;:::-;3800:38;;;3819:1;3800:38;3786:52;;3855:43;3871:10;3883:1;3886:11;3855:15;:43::i;:::-;3848:50;;;3683:222;:::o;7834:644::-;7910:4;7943:9;:7;:9::i;:::-;7934:5;:18;;7926:43;;;;-1:-1:-1;;;7926:43:5;;5485:2:7;7926:43:5;;;5467:21:7;5524:2;5504:18;;;5497:30;-1:-1:-1;;;5543:18:7;;;5536:42;5595:18;;7926:43:5;5283:336:7;7926:43:5;8192:18;8213:40;8237:8;8247:5;8213:23;:40::i;:::-;8192:61;;8267:13;8284:1;8267:18;8263:32;;8294:1;8287:8;;;;;8263:32;8314:20;8337:29;8360:5;8337:22;:29::i;:::-;8314:52;;8380:15;8399:1;8380:20;8376:34;;8409:1;8402:8;;;;;;8376:34;8456:15;8428:25;305:4;8428:13;:25;:::i;:::-;:43;;;;:::i;:::-;8421:50;;;;7834:644;;;;;:::o;9736:367::-;9883:14;9909:16;9928:9;:7;:9::i;:::-;9909:28;;9968:11;9951:13;:28;9947:65;;9997:15;10011:1;9997:11;:15;:::i;:::-;9981:31;;9947:65;10029:67;10055:8;10065:15;10082:13;10029:25;:67::i;:::-;10022:74;9736:367;-1:-1:-1;;;;;9736:367:5:o;13355:196::-;13448:10;13432:27;;;;:15;:27;;;;;;;;-1:-1:-1;;;;;13432:37:5;;;;;;;;;;;;:49;;-1:-1:-1;;13432:49:5;;;;;;;;;;13496:48;;964:41:7;;;13432:37:5;;13448:10;13496:48;;937:18:7;13496:48:5;824:187:7;8484:324:5;8602:42;;-1:-1:-1;;;8602:42:5;;-1:-1:-1;;;;;6211:32:7;;;8602:42:5;;;6193:51:7;6260:18;;;6253:34;;;8568:4:5;;;;8602:6;:25;;;;6166:18:7;;8602:42:5;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;8584:60;;8658:10;8672:1;8658:15;8654:29;;8682:1;8675:8;;;;;8654:29;-1:-1:-1;;;;;8713:6:5;:29;;8743:8;8753:30;8761:22;8753:5;:30;:::i;:::-;8713:71;;-1:-1:-1;;;;;;8713:71:5;;;;;;;-1:-1:-1;;;;;6211:32:7;;;8713:71:5;;;6193:51:7;6260:18;;;6253:34;6166:18;;8713:71:5;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:88;8700:101;;-1:-1:-1;;;;;8700:101:5;:10;:101;:::i;10691:1014::-;10762:19;10783:17;10812:16;10831:9;:7;:9::i;:::-;10812:28;;10854:11;10869:1;10854:16;10850:35;;-1:-1:-1;10880:1:5;;;;-1:-1:-1;10691:1014:5;-1:-1:-1;;10691:1014:5:o;10850:35::-;-1:-1:-1;;;;;10939:21:5;;10895:13;10939:21;;;:11;:21;;;;;:35;-1:-1:-1;;;10939:35:5;;-1:-1:-1;;;;;10939:35:5;11010:10;-1:-1:-1;;11010:55:5;;11052:13;11010:55;;;11039:10;11010:55;10993:72;;11117:216;11156:11;11138:14;:29;11117:216;;11249:1;11205:41;11221:8;11231:14;11205:15;:41::i;:::-;:45;11201:122;;;11281:4;11270:15;;11303:5;;11201:122;11169:16;;;;:::i;:::-;;;;11117:216;;;11348:8;11343:27;;-1:-1:-1;11366:1:5;;;;-1:-1:-1;10691:1014:5;-1:-1:-1;;;;10691:1014:5:o;11343:27::-;11476:15;11490:1;11476:11;:15;:::i;:::-;11461:30;;11456:195;11508:14;11493:12;:29;11456:195;;;11600:1;11558:39;11574:8;11584:12;11558:15;:39::i;:::-;:43;11621:5;11554:87;11524:14;;;;:::i;:::-;;;;11456:195;;;11661:37;;;10691:1014;;;:::o;400:118:6:-;440:12;504:7;472:28;490:10;472:15;:28;:::i;:::-;471:40;;;;:::i;:::-;464:47;;400:118;:::o;3149:237:5:-;3207:4;3223:9;3235;:7;:9::i;:::-;3223:21;;3266:4;3257:5;:13;3254:26;;-1:-1:-1;3279:1:5;;3149:237;-1:-1:-1;;3149:237:5:o;3254:26::-;3293:29;3316:5;3293:22;:29::i;:::-;:34;3290:47;;-1:-1:-1;3336:1:5;;3149:237;-1:-1:-1;;3149:237:5:o;3290:47::-;-1:-1:-1;;3354:18:5;:25;;;;;;;;;;;;3149:237::o;5009:209::-;5115:18;5152:59;5168:10;5180:15;5197:13;5152:15;:59::i;9228:253::-;9291:14;9318:19;9339:17;9360:32;9383:8;9360:22;:32::i;:::-;9317:75;;;;9409:65;9435:8;9445:14;9461:12;9409:25;:65::i;11888:216::-;11988:17;12029:9;:7;:9::i;:::-;12020:5;:18;12017:31;;-1:-1:-1;12047:1:5;12040:8;;12017:31;12065:32;12081:8;12091:5;12065:15;:32::i;12967:178::-;13046:10;13034:23;;;;:11;:23;;;;;;:46;;-1:-1:-1;;;;;;13034:46:5;-1:-1:-1;;;;;13034:46:5;;;;;;;;13095:43;;13034:46;;13046:10;13095:43;;;12967:178;:::o;2603:331::-;2654:4;2670:9;2682;:7;:9::i;:::-;2670:21;;2701:11;2715:22;2731:5;2715:15;:22::i;:::-;2701:36;;2750:6;2760:1;2750:11;2747:28;;-1:-1:-1;2770:5:5;;2603:331;-1:-1:-1;;;2603:331:5:o;2747:28::-;2813:1;2785:25;;;;;;;;;;;:29;;;2824:24;;;;;:34;;2852:6;;2813:1;2824:34;;2852:6;;2824:34;:::i;:::-;;;;-1:-1:-1;;2873:33:5;;160:25:7;;;2893:4:5;;2886:5;;2873:33;;148:2:7;133:18;2873:33:5;;;;;;;-1:-1:-1;2923:4:5;;2603:331;-1:-1:-1;;;2603:331:5:o;4242:301::-;4296:18;4334:23;4348:8;4334:13;:23::i;:::-;4326:52;;;;-1:-1:-1;;;4326:52:5;;5140:2:7;4326:52:5;;;5122:21:7;5179:2;5159:18;;;5152:30;-1:-1:-1;;;5198:18:7;;;5191:46;5254:18;;4326:52:5;4938:340:7;4326:52:5;4388:16;4407:9;:7;:9::i;:::-;4388:28;-1:-1:-1;4440:16:5;;:38;;4463:15;4477:1;4463:11;:15;:::i;:::-;4440:38;;;4459:1;4440:38;4426:52;;4495:41;4511:8;4521:1;4524:11;4495:15;:41::i;1329:203:4:-;1456:68;;-1:-1:-1;;;;;6837:15:7;;;1456:68:4;;;6819:34:7;6889:15;;6869:18;;;6862:43;6921:18;;;6914:34;;;1429:96:4;;1449:5;;-1:-1:-1;;;1479:27:4;6754:18:7;;1456:68:4;;;;-1:-1:-1;;1456:68:4;;;;;;;;;;;;;;-1:-1:-1;;;;;1456:68:4;-1:-1:-1;;;;;;1456:68:4;;;;;;;;;;1429:19;:96::i;:::-;1329:203;;;;:::o;12498:166:5:-;-1:-1:-1;;;;;12594:25:5;;12562:13;12594:25;;;:15;:25;;;;;;;;12620:10;12594:37;;;;;;;;;;;:63;;-1:-1:-1;;;;;;12635:22:5;;12647:10;12635:22;12587:70;12498:166;-1:-1:-1;;12498:166:5:o;6283:1019::-;6416:18;6446:16;6465:9;:7;:9::i;:::-;6446:28;;6504:11;6487:13;:28;6484:41;;6524:1;6517:8;;;;;6484:41;-1:-1:-1;;;;;6563:21:5;;6536:24;6563:21;;;:11;:21;;;;;6651:18;;6563:21;;6536:24;-1:-1:-1;;;6651:18:5;;-1:-1:-1;;;;;6651:18:5;:23;:57;;6690:18;;-1:-1:-1;;;6690:18:5;;-1:-1:-1;;;;;6690:18:5;6651:57;;;6677:10;6651:57;6630:78;;6736:35;6740:13;6755:15;6736:3;:35::i;:::-;6718:53;;6802:13;6784:15;:31;6781:44;;;6824:1;6817:8;;;;;;;6781:44;6860:67;6886:8;6896:15;6913:13;6860:25;:67::i;:::-;6844:83;-1:-1:-1;6946:18:5;6963:1;6946:18;;:::i;:::-;6974:42;;-1:-1:-1;;;;;6974:42:5;-1:-1:-1;;;;;;;;6974:42:5;;;;;;;-1:-1:-1;7039:17:5;;7035:261;;7092:14;;7072:17;;-1:-1:-1;;;;;7092:14:5;:28;:56;;7134:14;;-1:-1:-1;;;;;7134:14:5;7092:56;;;7123:8;7092:56;7072:76;-1:-1:-1;7162:50:5;-1:-1:-1;;;;;7162:11:5;:24;7072:76;7198:13;7162:24;:50::i;:::-;7256:13;7246:8;-1:-1:-1;;;;;7231:54:5;;7271:13;7231:54;;;;160:25:7;;148:2;133:18;;14:177;7231:54:5;;;;;;;;7058:238;7035:261;6436:866;;;6283:1019;;;;;:::o;10109:314::-;10257:20;10303:15;10289:128;10325:13;10320:1;:18;10289:128;;10378:28;10394:8;10404:1;10378:15;:28::i;:::-;10359:47;;;;:::i;:::-;;-1:-1:-1;10340:3:5;;;:::i;:::-;;;10289:128;;;;10109:314;;;;;:::o;12110:382::-;-1:-1:-1;;;;;12251:21:5;;12211:17;12251:21;;;:11;:21;;;;;:35;-1:-1:-1;;;12251:35:5;;-1:-1:-1;;;;;12251:35:5;12243:43;;12240:56;;;-1:-1:-1;12295:1:5;12288:8;;12240:56;12306:16;12325:32;12341:8;12351:5;12325:15;:32::i;:::-;12367:22;12392:25;;;;;;;;;;;12306:51;;-1:-1:-1;305:4:5;12442:31;12392:25;12306:51;12442:31;:::i;5170:642:4:-;5589:23;5615:69;5643:4;5615:69;;;;;;;;;;;;;;;;;5623:5;-1:-1:-1;;;;;5615:27:4;;;:69;;;;;:::i;:::-;5589:95;;5702:10;:17;5723:1;5702:22;:56;;;;5739:10;5728:30;;;;;;;;;;;;:::i;:::-;5694:111;;;;-1:-1:-1;;;5694:111:4;;7411:2:7;5694:111:4;;;7393:21:7;7450:2;7430:18;;;7423:30;7489:34;7469:18;;;7462:62;-1:-1:-1;;;7540:18:7;;;7533:40;7590:19;;5694:111:4;7209:406:7;5694:111:4;5240:572;5170:642;;:::o;13557:95:5:-;13609:4;13636:1;13632;:5;:13;;13644:1;13632:13;;;-1:-1:-1;13640:1:5;13557:95;-1:-1:-1;13557:95:5:o;915:175:4:-;1024:58;;-1:-1:-1;;;;;6211:32:7;;1024:58:4;;;6193:51:7;6260:18;;;6253:34;;;997:86:4;;1017:5;;-1:-1:-1;;;1047:23:4;6166:18:7;;1024:58:4;6019:274:7;3873:223:0;4006:12;4037:52;4059:6;4067:4;4073:1;4076:12;4006;5241;5255:23;5282:6;-1:-1:-1;;;;;5282:11:0;5301:5;5308:4;5282:31;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5240:73;;;;5330:69;5357:6;5365:7;5374:10;5386:12;5330:26;:69::i;:::-;5323:76;4960:446;-1:-1:-1;;;;;;;4960:446:0:o;7466:628::-;7646:12;7674:7;7670:418;;;7701:10;:17;7722:1;7701:22;7697:286;;-1:-1:-1;;;;;1465:19:0;;;7908:60;;;;-1:-1:-1;;;7908:60:0;;8535:2:7;7908:60:0;;;8517:21:7;8574:2;8554:18;;;8547:30;8613:31;8593:18;;;8586:59;8662:18;;7908:60:0;8333:353:7;7908:60:0;-1:-1:-1;8003:10:0;7996:17;;7670:418;8044:33;8052:10;8064:12;8775:17;;:21;8771:379;;9003:10;8997:17;9059:15;9046:10;9042:2;9038:19;9031:44;8771:379;9126:12;9119:20;;-1:-1:-1;;;9119:20:0;;;;;;;;:::i;196:180:7:-;255:6;308:2;296:9;287:7;283:23;279:32;276:52;;;324:1;321;314:12;276:52;-1:-1:-1;347:23:7;;196:180;-1:-1:-1;196:180:7:o;381:173::-;449:20;;-1:-1:-1;;;;;498:31:7;;488:42;;478:70;;544:1;541;534:12;478:70;381:173;;;:::o;559:260::-;627:6;635;688:2;676:9;667:7;663:23;659:32;656:52;;;704:1;701;694:12;656:52;727:29;746:9;727:29;:::i;:::-;717:39;;775:38;809:2;798:9;794:18;775:38;:::i;:::-;765:48;;559:260;;;;;:::o;1016:322::-;1093:6;1101;1109;1162:2;1150:9;1141:7;1137:23;1133:32;1130:52;;;1178:1;1175;1168:12;1130:52;1201:29;1220:9;1201:29;:::i;:::-;1191:39;1277:2;1262:18;;1249:32;;-1:-1:-1;1328:2:7;1313:18;;;1300:32;;1016:322;-1:-1:-1;;;1016:322:7:o;1578:254::-;1646:6;1654;1707:2;1695:9;1686:7;1682:23;1678:32;1675:52;;;1723:1;1720;1713:12;1675:52;1746:29;1765:9;1746:29;:::i;:::-;1736:39;1822:2;1807:18;;;;1794:32;;-1:-1:-1;;;1578:254:7:o;1837:118::-;1923:5;1916:13;1909:21;1902:5;1899:32;1889:60;;1945:1;1942;1935:12;1960:315;2025:6;2033;2086:2;2074:9;2065:7;2061:23;2057:32;2054:52;;;2102:1;2099;2092:12;2054:52;2125:29;2144:9;2125:29;:::i;:::-;2115:39;;2204:2;2193:9;2189:18;2176:32;2217:28;2239:5;2217:28;:::i;:::-;2264:5;2254:15;;;1960:315;;;;;:::o;2280:186::-;2339:6;2392:2;2380:9;2371:7;2367:23;2363:32;2360:52;;;2408:1;2405;2398:12;2360:52;2431:29;2450:9;2431:29;:::i;2724:248::-;2792:6;2800;2853:2;2841:9;2832:7;2828:23;2824:32;2821:52;;;2869:1;2866;2859:12;2821:52;-1:-1:-1;;2892:23:7;;;2962:2;2947:18;;;2934:32;;-1:-1:-1;2724:248:7:o;3509:127::-;3570:10;3565:3;3561:20;3558:1;3551:31;3601:4;3598:1;3591:15;3625:4;3622:1;3615:15;3641:125;3706:9;;;3727:10;;;3724:36;;;3740:18;;:::i;3771:184::-;3841:6;3894:2;3882:9;3873:7;3869:23;3865:32;3862:52;;;3910:1;3907;3900:12;3862:52;-1:-1:-1;3933:16:7;;3771:184;-1:-1:-1;3771:184:7:o;3960:188::-;4039:13;;-1:-1:-1;;;;;4081:42:7;;4071:53;;4061:81;;4138:1;4135;4128:12;4153:647;4249:6;4302:2;4290:9;4281:7;4277:23;4273:32;4270:52;;;4318:1;4315;4308:12;4270:52;4351:2;4345:9;4393:2;4385:6;4381:15;4462:6;4450:10;4447:22;4426:18;4414:10;4411:34;4408:62;4405:185;;;4512:10;4507:3;4503:20;4500:1;4493:31;4547:4;4544:1;4537:15;4575:4;4572:1;4565:15;4405:185;4606:2;4599:22;4645:40;4675:9;4645:40;:::i;:::-;4637:6;4630:56;4719:49;4764:2;4753:9;4749:18;4719:49;:::i;:::-;4714:2;4702:15;;4695:74;4706:6;4153:647;-1:-1:-1;;;4153:647:7:o;4805:128::-;4872:9;;;4893:11;;;4890:37;;;4907:18;;:::i;5624:168::-;5697:9;;;5728;;5745:15;;;5739:22;;5725:37;5715:71;;5766:18;;:::i;5797:217::-;5837:1;5863;5853:132;;5907:10;5902:3;5898:20;5895:1;5888:31;5942:4;5939:1;5932:15;5970:4;5967:1;5960:15;5853:132;-1:-1:-1;5999:9:7;;5797:217::o;6298:135::-;6337:3;6358:17;;;6355:43;;6378:18;;:::i;:::-;-1:-1:-1;6425:1:7;6414:13;;6298:135::o;6438:136::-;6477:3;6505:5;6495:39;;6514:18;;:::i;:::-;-1:-1:-1;;;6550:18:7;;6438:136::o;6959:245::-;7026:6;7079:2;7067:9;7058:7;7054:23;7050:32;7047:52;;;7095:1;7092;7085:12;7047:52;7127:9;7121:16;7146:28;7168:5;7146:28;:::i;8027:301::-;8156:3;8194:6;8188:13;8240:6;8233:4;8225:6;8221:17;8216:3;8210:37;8302:1;8266:16;;8291:13;;;-1:-1:-1;8266:16:7;8027:301;-1:-1:-1;8027:301:7:o;8691:418::-;8840:2;8829:9;8822:21;8803:4;8872:6;8866:13;8915:6;8910:2;8899:9;8895:18;8888:34;8974:6;8969:2;8961:6;8957:15;8952:2;8941:9;8937:18;8931:50;9030:1;9025:2;9016:6;9005:9;9001:22;8997:31;8990:42;9100:2;9093;9089:7;9084:2;9076:6;9072:15;9068:29;9057:9;9053:45;9049:54;9041:62;;;8691:418;;;;:::o

ipfs://bcb8e98f1a28212e899dc28c15606fa365b931d68b349e2ffcb80ecf9fe9f678