User
start review this contract line by line and understand with higher understanding with knowledge every line with function and focus on this and find some unique issue if there are exist 
 
# Issues to ignore

The following categories of issues are out of scope for this audit.

- Issues that posit a malicious sequencer operator
- Issues related to centralization concerns
- Concerns about the incentives for smart contracts to optimize their gas given that they can claim the sequencer fees caused by their contracts
- Concerns about regulating Blast’s block space since smart contracts can claim their sequencer fees
- Frontrunning yield updates
- Increasingly inefficient balance representations caused by Blast’s limited precision, constantly increasing share prices
- Locked funds caused by the sequencer operator finalizing withdrawal requests that turned out to be faulty (i.e. the output root changed)

here is the contract : 
// SPDX-License-Identifier: BSL 1.1 - Copyright 2024 MetaLayer Labs Ltd.
pragma solidity 0.8.15;

import { Initializable } from "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
import { IERC20 } from "@openzeppelin/contracts/interfaces/IERC20.sol";

import { SharesBase } from "src/L2/Shares.sol";
import { YieldMode } from "src/L2/Blast.sol";
import { ERC20PermitUpgradeable } from "src/L2/ERC20PermitUpgradeable.sol";

/// @custom:upgradeable
/// @title ERC20Rebasing
/// @notice ERC20 implementation with rebasing token balances. There are 3 yield
/// modes with different rebasing behaviors.
///
/// AUTOMATIC dynamically updates the balance as the share price increases.
///
/// VOID fixes the balance and exempts the account from receiving yields.
///
/// CLAIMABLE fixes the balance and allows the account to claim yields to
/// another account.
///
/// The child implementation is responsible for deciding how the share price is set.
abstract contract ERC20Rebasing is ERC20PermitUpgradeable, SharesBase, IERC20 {
    /// @notice Number of decimals.
    uint8 public immutable decimals;

    /// @notice Name of the token.
    string public name;
    /// @notice Symbol of the token.
    string public symbol;

    /// @notice Mapping that stores the number of shares for each account.
    mapping(address => uint256) private _shares;

    /// @notice Total number of shares distributed.
    uint256 internal _totalShares;

    /// @notice Mapping that stores the number of remainder tokens for each account.
    mapping(address => uint256) private _remainders;

    /// @notice Mapping that stores the number of fixed tokens for each account.
    mapping(address => uint256) private _fixed;

    /// @notice Total number of non-rebasing tokens.
    uint256 internal _totalVoidAndRemainders;

    /// @notice Mapping that stores the configured yield mode for each account.
    mapping(address => YieldMode) private _yieldMode;

    /// @notice Mapping that stores the allowance for a given spender and operator pair.
    mapping(address => mapping(address => uint256)) private _allowances;

    /// @notice Reserve extra slots (to a total of 50) in the storage layout for future upgrades.
    ///         A gap size of 41 was chosen here, so that the first slot used in a child contract
    ///         would be a multiple of 50.
    uint256[41] private __gap;

    /// @notice Emitted when an account configures their yield mode.
    /// @param account   Address of the account.
    /// @param yieldMode Yield mode that was configured.
    event Configure(address indexed account, YieldMode yieldMode);

    /// @notice Emitted when a CLAIMABLE account claims their yield.
    /// @param account   Address of the account.
    /// @param recipient Address of the recipient.
    /// @param amount    Amount of yield claimed.
    event Claim(address indexed account, address indexed recipient, uint256 amount);

    error InsufficientBalance();
    error InsufficientAllowance();
    error TransferFromZeroAddress();
    error TransferToZeroAddress();
    error ApproveFromZeroAddress();
    error ApproveToZeroAddress();
    error ClaimToZeroAddress();
    error NotClaimableAccount();

    /// @param _decimals Number of decimals.
    constructor(address _reporter, uint8 _decimals) SharesBase(_reporter) {
        decimals = _decimals;
    }

    /// @param _name     Token name.
    /// @param _symbol   Token symbol.
    /// @param _price    Initial share price.
    function __ERC20Rebasing_init(string memory _name, string memory _symbol, uint256 _price) internal onlyInitializing {
        __ERC20Permit_init(_name);
        __SharesBase_init({ _price: _price });
        name = _name;
        symbol = _symbol;
    }

    /// @inheritdoc SharesBase
    function count() public view override returns (uint256) {
        return _totalShares;
    }

    /// @notice --- ERC20 Interface ---

    /// @inheritdoc IERC20
    function totalSupply() external view returns (uint256) {
        return price * _totalShares + _totalVoidAndRemainders;
    }

    /// @inheritdoc IERC20
    function balanceOf(address account)
        public
        view
        virtual
        returns (uint256 value)
    {
        YieldMode yieldMode = _yieldMode[account];
        if (yieldMode == YieldMode.AUTOMATIC) {
            value = _computeShareValue(_shares[account], _remainders[account]);
        } else {
            value = _fixed[account];
        }
    }

    /// @inheritdoc IERC20
    function allowance(address owner, address spender)
        public
        view
        virtual
        returns (uint256)
    {
        return _allowances[owner][spender];
    }

    /// @inheritdoc IERC20
    function transfer(address to, uint256 amount)
        public
        virtual
        returns (bool)
    {
        _transfer(msg.sender, to, amount);
        return true;
    }

    /// @inheritdoc IERC20
    function approve(address spender, uint256 amount)
        public
        virtual
        returns (bool)
    {
        address owner = msg.sender;
        _approve(owner, spender, amount);
        return true;
    }

    /// @inheritdoc IERC20
    function transferFrom(
        address from,
        address to,
        uint256 amount
    ) public virtual returns (bool) {
        _spendAllowance(from, msg.sender, amount);
        _transfer(from, to, amount);
        return true;
    }

    /// @notice --- Blast Interface ---

    /// @notice Query an account's configured yield mode.
    /// @param account Address to query the configuration.
    /// @return Configured yield mode.
    function getConfiguration(address account) public view returns (YieldMode) {
        return _yieldMode[account];
    }

    /// @notice Query an CLAIMABLE account's claimable yield.
    /// @param account Address to query the claimable amount.
    /// @return amount Claimable amount.
    function getClaimableAmount(address account) public view returns (uint256) {
        if (getConfiguration(account) != YieldMode.CLAIMABLE) {
            revert NotClaimableAccount();
        }

        uint256 shareValue = _computeShareValue(_shares[account], _remainders[account]);
        return shareValue - _fixed[account];
    }

    /// @notice Claim yield from a CLAIMABLE account and send to
    ///         a recipient.
    /// @param recipient Address to receive the claimed balance.
    /// @param amount    Amount to claim.
    /// @return Amount claimed.
    function claim(address recipient, uint256 amount) external returns (uint256) {
        address account = msg.sender;
        if (recipient == address(0)) {
            revert ClaimToZeroAddress();
        }

        if (getConfiguration(account) != YieldMode.CLAIMABLE) {
            revert NotClaimableAccount();
        }

        uint256 shareValue = _computeShareValue(_shares[account], _remainders[account]);

        uint256 claimableAmount = shareValue - _fixed[account];
        if (amount > claimableAmount) {
            revert InsufficientBalance();
        }

        (uint256 newShares, uint256 newRemainder) = _computeSharesAndRemainder(shareValue - amount);

        _updateBalance(account, newShares, newRemainder, _fixed[account]);
        _deposit(recipient, amount);

        emit Claim(msg.sender, recipient, amount);

        return amount;
    }

    /// @notice Change the yield mode of the caller and update the
    ///         balance to reflect the configuration.
    /// @param yieldMode Yield mode to configure
    /// @return Current user balance
    function configure(YieldMode yieldMode) external returns (uint256) {
        _configure(msg.sender, yieldMode);

        emit Configure(msg.sender, yieldMode);

        return balanceOf(msg.sender);
    }

    /// @notice Moves `amount` of tokens from `from` to `to`.
    /// @param from   Address of the sender.
    /// @param to     Address of the recipient.
    /// @param amount Amount of tokens to send.
    function _transfer(
        address from,
        address to,
        uint256 amount
    ) internal virtual {
        if (from == address(0)) revert TransferFromZeroAddress();
        if (to == address(0)) revert TransferToZeroAddress();

        _withdraw(from, amount);
        _deposit(to, amount);

        emit Transfer(from, to, amount);
    }

    /// @notice Sets `amount` as the allowance of `spender` over the `owner` s tokens.
    /// @param owner   Address of the owner.
    /// @param spender Address of the spender.
    /// @param amount  Amount of tokens to approve.
    function _approve(
        address owner,
        address spender,
        uint256 amount
    ) internal override {
        if (owner == address(0)) revert ApproveFromZeroAddress();
        if (spender == address(0)) revert ApproveToZeroAddress();

        _allowances[owner][spender] = amount;
        emit Approval(owner, spender, amount);
    }

    /// @notice Updates `owner` s allowance for `spender` based on spent `amount`.
    /// @param owner   Address of the owner.
    /// @param spender Address of the spender.
    /// @param amount  Amount of tokens to spender.
    function _spendAllowance(
        address owner,
        address spender,
        uint256 amount
    ) internal virtual {
        uint256 currentAllowance = allowance(owner, spender);
        if (currentAllowance != type(uint256).max) {
            if (amount > currentAllowance) revert InsufficientAllowance();
            unchecked {
                _approve(owner, spender, currentAllowance - amount);
            }
        }
    }

    /// @notice Deposit to an account.
    /// @param account Address of the account to deposit to.
    /// @param amount  Amount to deposit to the account.
    function _deposit(address account, uint256 amount) internal {
        uint256 balanceAfter = balanceOf(account) + amount;
        _setBalance(account, balanceAfter, false);

        /// If the user is configured as VOID, then the amount
        /// is added to the total voided funds.
        YieldMode yieldMode = getConfiguration(account);
        if (yieldMode == YieldMode.VOID) {
            _totalVoidAndRemainders += amount;
        }
    }

    /// @notice Withdraw from an account.
    /// @param account Address of the account to withdraw from.
    /// @param amount  Amount to withdraw to the account.
    function _withdraw(address account, uint256 amount) internal {
        uint256 balance = balanceOf(account);
        if (amount > balance) {
            revert InsufficientBalance();
        }

        unchecked {
            _setBalance(account, balance - amount, false);
        }

        /// If the user is configured as VOID, then the amount
        /// is deducted from the total voided funds.
        YieldMode yieldMode = getConfiguration(account);
        if (yieldMode == YieldMode.VOID) {
            _totalVoidAndRemainders -= amount;
        }
    }

    /// @notice Configures a new yield mode for an account and updates
    ///         the balance storage to reflect the change.
    /// @param account      Address of the account to configure.
    /// @param newYieldMode New yield mode to configure.
    function _configure(address account, YieldMode newYieldMode) internal {
        YieldMode prevYieldMode = getConfiguration(account);

        uint256 balance;
        if (prevYieldMode == YieldMode.CLAIMABLE) {
            /// If the balance is claimable, we need to use their share balance so they
            /// don't lose their claimable yield.
            balance = _computeShareValue(_shares[account], _remainders[account]);
        } else {
            balance = balanceOf(account);
        }

        _yieldMode[account] = newYieldMode;

        uint256 prevFixed = _fixed[account];

        _setBalance(account, balance, true);

        /// If the previous yield mode was VOID, then the amount
        /// is deducted from the total voided funds.
        if (prevYieldMode == YieldMode.VOID) {
            _totalVoidAndRemainders -= prevFixed;
        }

        /// If the new yield mode is VOID, then the amount
        /// is added to the total voided funds.
        if (newYieldMode == YieldMode.VOID) {
            _totalVoidAndRemainders += balance;
        }
    }

    /// @notice Sets the balance of an account according to its yield mode
    ///         configuration.
    /// @param account           Address of the account to set the balance of.
    /// @param amount            Balance to set for the account.
    /// @param resetClaimable    If the account is CLAIMABLE, true if the share
    ///                          balance should be set to the amount. Should only be true when
    ///                          configuring the account.
    function _setBalance(address account, uint256 amount, bool resetClaimable) internal {
        uint256 newShares; uint256 newRemainder; uint256 newFixed;
        YieldMode yieldMode = getConfiguration(account);
        if (yieldMode == YieldMode.AUTOMATIC) {
            (newShares, newRemainder) = _computeSharesAndRemainder(amount);
        } else if (yieldMode == YieldMode.VOID) {
            newFixed = amount;
        } else if (yieldMode == YieldMode.CLAIMABLE) {
            newFixed = amount;
            uint256 shareValue = amount;
            if (!resetClaimable) {
                /// In order to not reset the claimable balance, we have to compute
                /// the user's current share balance and add or subtract the change in
                /// fixed balance before computing the new shares balance parameters.
                shareValue = _computeShareValue(_shares[account], _remainders[account]);
                shareValue = shareValue + amount - _fixed[account];
            }
            (newShares, newRemainder) = _computeSharesAndRemainder(shareValue);
        }

        _updateBalance(account, newShares, newRemainder, newFixed);
    }

    /// @notice Update the balance parameters of an account and appropriately refresh the global sums
    ///         to reflect the change of allocation.
    /// @param account      Address of account to update.
    /// @param newShares    New shares value for account.
    /// @param newRemainder New remainder value for account.
    /// @param newFixed     New fixed value for account.
    function _updateBalance(address account, uint256 newShares, uint256 newRemainder, uint256 newFixed) internal {
        _totalShares = _totalShares + newShares - _shares[account];
        _totalVoidAndRemainders = _totalVoidAndRemainders + newRemainder - _remainders[account];

        _shares[account] = newShares;
        _remainders[account] = newRemainder;
        _fixed[account] = newFixed;
    }

    /// @notice Convert nominal value to number of shares with remainder.
    /// @param value Amount to convert to shares (wad).
    /// @return shares Number of shares (wad), remainder Remainder (wad).
    function _computeSharesAndRemainder(uint256 value) internal view returns (uint256 shares, uint256 remainder) {
        if (price == 0) {
            remainder = value;
        } else {
            shares = value / price;
            remainder = value % price;
        }
    }

    /// @notice Compute nominal value from number of shares.
    /// @param shares     Number of shares (wad).
    /// @param remainders Amount of remainder (wad).
    /// @return value (wad).
    function _computeShareValue(uint256 shares, uint256 remainders) internal view returns (uint256) {
        return price * shares + remainders;
    }
}
 and this contract is import  SharesBase from Shares.sol contract :
// SPDX-License-Identifier: BSL 1.1 - Copyright 2024 MetaLayer Labs Ltd.
pragma solidity 0.8.15;

import { Initializable } from "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";

import { Semver } from "src/universal/Semver.sol";
import { AddressAliasHelper } from "src/vendor/AddressAliasHelper.sol";
import { Predeploys } from "src/libraries/Predeploys.sol";
import { Blast, YieldMode, GasMode } from "src/L2/Blast.sol";

/// @custom:predeploy 0x4300000000000000000000000000000000000000
/// @title SharesBase
/// @notice Base contract to track share rebasing and yield reporting.
abstract contract SharesBase is Initializable {
    /// @notice Approved yield reporter.
    address public immutable REPORTER;

    /// @notice Share price. This value can only increase.
    uint256 public price;

    /// @notice Accumulated yield that has not been distributed
    ///         to the share price.
    uint256 public pending;

    /// @notice Reserve extra slots (to a total of 50) in the storage layout for future upgrades.
    ///         A gap size of 48 was chosen here, so that the first slot used in a child contract
    ///         would be a multiple of 50.
    uint256[48] private __gap;

    /// @notice Emitted when a new share price is set after a yield event.
    event NewPrice(uint256 price);

    error InvalidReporter();
    error DistributeFailed(uint256 count, uint256 pending);
    error PriceIsInitialized();

    /// @param _reporter Address of the approved yield reporter.
    constructor(address _reporter) {
        REPORTER = _reporter;
    }

    /// @notice Initializer.
    /// @param _price Initial share price.
    // solhint-disable-next-line func-name-mixedcase
    function __SharesBase_init(uint256 _price) internal onlyInitializing {
        if (price != 0) {
            revert PriceIsInitialized();
        }
        price = _price;
    }

    /// @notice Get the total number of shares. Needs to be
    ///         overridden by the child contract.
    /// @return Total number of shares.
    function count() public view virtual returns (uint256);

    /// @notice Report a yield event and update the share price.
    /// @param value Amount of new yield
    function addValue(uint256 value) external {
        _addValue(value);
    }

    function _addValue(uint256 value) internal virtual {
        if (AddressAliasHelper.undoL1ToL2Alias(msg.sender) != REPORTER) {
            revert InvalidReporter();
        }

        if (value > 0) {
            pending += value;
        }

        _tryDistributePending();
    }

    /// @notice Distribute pending yields.
    function distributePending() external {
        if (!_tryDistributePending()) {
            revert DistributeFailed(count(), pending);
        }
    }

    /// @notice Attempt to distribute pending yields if there
    ///         are sufficient pending yields to increase the
    ///         share price.
    /// @return True if there were sufficient pending yields to
    ///         increase the share price.
    function _tryDistributePending() internal returns (bool) {
        if (pending < count() || count() == 0) {
            return false;
        }

        price += pending / count();
        pending = pending % count();

        emit NewPrice(price);

        return true;
    }
}

/// @custom:predeploy 0x4300000000000000000000000000000000000000
/// @title Shares
/// @notice Integrated EVM contract to manage native ether share
///         rebasing from yield reports.
contract Shares is SharesBase, Semver {
    /// @notice Total number of shares. This value is modified directly
    ///         by the sequencer EVM.
    uint256 private _count;

    /// @notice _reporter Address of approved yield reporter.
    constructor(address _reporter) SharesBase(_reporter) Semver(1, 0, 0) {
        _disableInitializers();
    }

    /// @notice Initializer.
    function initialize(uint256 _price) public initializer {
        __SharesBase_init({ _price: _price });
        Blast(Predeploys.BLAST).configureContract(
            address(this),
            YieldMode.VOID,
            GasMode.VOID,
            address(0xdead) /// don't set a governor
        );
    }

    /// @inheritdoc SharesBase
    function count() public view override returns (uint256) {
        return _count;
    }

    function _addValue(uint256 value) internal override {
        super._addValue(value);

        SharesBase(Predeploys.WETH_REBASING).addValue(value);
    }
}
 and it's import  YieldMode from the Blast.sol contract :
pragma solidity 0.8.15;

import { GasMode, IGas } from "src/L2/Gas.sol";

enum YieldMode {
    AUTOMATIC,
    VOID,
    CLAIMABLE
}

interface IYield {
    function configure(address contractAddress, uint8 flags) external returns (uint256);
    function claim(address contractAddress, address recipientOfYield, uint256 desiredAmount) external returns (uint256);
    function getClaimableAmount(address contractAddress) external view returns (uint256);
    function getConfiguration(address contractAddress) external view returns (uint8);
}

interface IBlast{
    // configure
    function configureContract(address contractAddress, YieldMode _yield, GasMode gasMode, address governor) external;
    function configure(YieldMode _yield, GasMode gasMode, address governor) external;

    // base configuration options
    function configureClaimableYield() external;
    function configureClaimableYieldOnBehalf(address contractAddress) external;
    function configureAutomaticYield() external;
    function configureAutomaticYieldOnBehalf(address contractAddress) external;
    function configureVoidYield() external;
    function configureVoidYieldOnBehalf(address contractAddress) external;
    function configureClaimableGas() external;
    function configureClaimableGasOnBehalf(address contractAddress) external;
    function configureVoidGas() external;
    function configureVoidGasOnBehalf(address contractAddress) external;
    function configureGovernor(address _governor) external;
    function configureGovernorOnBehalf(address _newGovernor, address contractAddress) external;

    // claim yield
    function claimYield(address contractAddress, address recipientOfYield, uint256 amount) external returns (uint256);
    function claimAllYield(address contractAddress, address recipientOfYield) external returns (uint256);

    // claim gas
    function claimAllGas(address contractAddress, address recipientOfGas) external returns (uint256);
    function claimGasAtMinClaimRate(address contractAddress, address recipientOfGas, uint256 minClaimRateBips) external returns (uint256);
    function claimMaxGas(address contractAddress, address recipientOfGas) external returns (uint256);
    function claimGas(address contractAddress, address recipientOfGas, uint256 gasToClaim, uint256 gasSecondsToConsume) external returns (uint256);

    // read functions
    function readClaimableYield(address contractAddress) external view returns (uint256);
    function readYieldConfiguration(address contractAddress) external view returns (uint8);
    function readGasParams(address contractAddress) external view returns (uint256 etherSeconds, uint256 etherBalance, uint256 lastUpdated, GasMode);
}

contract Blast is IBlast {
    mapping(address => address) public governorMap;

    address public immutable YIELD_CONTRACT;
    address public immutable GAS_CONTRACT;

    constructor(address _gasContract, address _yieldContract) {
        GAS_CONTRACT = _gasContract;
        YIELD_CONTRACT = _yieldContract;
    }
    /**
     * @notice Checks if the caller is the governor of the contract
     * @param contractAddress The address of the contract
     * @return A boolean indicating if the caller is the governor
     */
    function isGovernor(address contractAddress) public view returns (bool) {
        return msg.sender == governorMap[contractAddress];
    }
    /**
     * @notice Checks if the governor is not set for the contract
     * @param contractAddress The address of the contract
     * @return boolean indicating if the governor is not set
     */
    function governorNotSet(address contractAddress) internal view returns (bool) {
        return governorMap[contractAddress] == address(0);
    }
    /**
     * @notice Checks if the caller is authorized
     * @param contractAddress The address of the contract
     * @return A boolean indicating if the caller is authorized
     */
    function isAuthorized(address contractAddress) public view returns (bool) {
        return isGovernor(contractAddress) || (governorNotSet(contractAddress) && msg.sender == contractAddress);
    }

    /**
     * @notice contract configures its yield and gas modes and sets the governor. called by contract
     * @param _yieldMode The yield mode to be set
     * @param _gasMode The gas mode to be set
     * @param governor The address of the governor to be set
     */
    function configure(YieldMode _yieldMode, GasMode _gasMode, address governor) external {
        // requires that no governor is set for contract
        require(isAuthorized(msg.sender), "not authorized to configure contract");
        // set governor
        governorMap[msg.sender] = governor;
        // set gas mode
        IGas(GAS_CONTRACT).setGasMode(msg.sender, _gasMode);
        // set yield mode
        IYield(YIELD_CONTRACT).configure(msg.sender, uint8(_yieldMode));
    }

    /**
     * @notice Configures the yield and gas modes and sets the governor for a specific contract. called by authorized user
     * @param contractAddress The address of the contract to be configured
     * @param _yieldMode The yield mode to be set
     * @param _gasMode The gas mode to be set
     * @param _newGovernor The address of the new governor to be set
     */
    function configureContract(address contractAddress, YieldMode _yieldMode, GasMode _gasMode, address _newGovernor) external {
        // only allow governor, or if no governor is set, the contract itself to configure
        require(isAuthorized(contractAddress), "not authorized to configure contract");
        // set governor
        governorMap[contractAddress] = _newGovernor;
        // set gas mode
        IGas(GAS_CONTRACT).setGasMode(contractAddress, _gasMode);
        // set yield mode
        IYield(YIELD_CONTRACT).configure(contractAddress, uint8(_yieldMode));
    }

    /**
     * @notice Configures the yield mode to CLAIMABLE for the contract that calls this function
     */
    function configureClaimableYield() external {
        require(isAuthorized(msg.sender), "not authorized to configure contract");
        IYield(YIELD_CONTRACT).configure(msg.sender, uint8(YieldMode.CLAIMABLE));
    }

    /**
     * @notice Configures the yield mode to CLAIMABLE for a specific contract. Called by an authorized user
     * @param contractAddress The address of the contract to be configured
     */
    function configureClaimableYieldOnBehalf(address contractAddress) external {
        require(isAuthorized(contractAddress), "not authorized to configure contract");
        IYield(YIELD_CONTRACT).configure(contractAddress, uint8(YieldMode.CLAIMABLE));
    }

    /**
     * @notice Configures the yield mode to AUTOMATIC for the contract that calls this function
     */
    function configureAutomaticYield() external {
        require(isAuthorized(msg.sender), "not authorized to configure contract");
        IYield(YIELD_CONTRACT).configure(msg.sender, uint8(YieldMode.AUTOMATIC));
    }

    /**
     * @notice Configures the yield mode to AUTOMATIC for a specific contract. Called by an authorized user
     * @param contractAddress The address of the contract to be configured
     */
    function configureAutomaticYieldOnBehalf(address contractAddress) external {
        require(isAuthorized(contractAddress), "not authorized to configure contract");
        IYield(YIELD_CONTRACT).configure(contractAddress, uint8(YieldMode.AUTOMATIC));
    }

    /**
     * @notice Configures the yield mode to VOID for the contract that calls this function
     */
    function configureVoidYield() external {
        require(isAuthorized(msg.sender), "not authorized to configure contract");
        IYield(YIELD_CONTRACT).configure(msg.sender, uint8(YieldMode.VOID));
    }

    /**
     * @notice Configures the yield mode to VOID for a specific contract. Called by an authorized user
     * @param contractAddress The address of the contract to be configured
     */
    function configureVoidYieldOnBehalf(address contractAddress) external {
        require(isAuthorized(contractAddress), "not authorized to configure contract");
        IYield(YIELD_CONTRACT).configure(contractAddress, uint8(YieldMode.VOID));
    }

    /**
     * @notice Configures the gas mode to CLAIMABLE for the contract that calls this function
     */
    function configureClaimableGas() external {
        require(isAuthorized(msg.sender), "not authorized to configure contract");
        IGas(GAS_CONTRACT).setGasMode(msg.sender, GasMode.CLAIMABLE);
    }

    /**
     * @notice Configures the gas mode to CLAIMABLE for a specific contract. Called by an authorized user
     * @param contractAddress The address of the contract to be configured
     */
    function configureClaimableGasOnBehalf(address contractAddress) external {
        require(isAuthorized(contractAddress), "not authorized to configure contract");
        IGas(GAS_CONTRACT).setGasMode(contractAddress, GasMode.CLAIMABLE);
    }

    /**
     * @notice Configures the gas mode to VOID for the contract that calls this function
     */
    function configureVoidGas() external {
        require(isAuthorized(msg.sender), "not authorized to configure contract");
        IGas(GAS_CONTRACT).setGasMode(msg.sender, GasMode.VOID);
    }

    /**
     * @notice Configures the gas mode to void for a specific contract. Called by an authorized user
     * @param contractAddress The address of the contract to be configured
     */
    function configureVoidGasOnBehalf(address contractAddress) external {
        require(isAuthorized(contractAddress), "not authorized to configure contract");
        IGas(GAS_CONTRACT).setGasMode(contractAddress, GasMode.VOID);
    }

    /**
     * @notice Configures the governor for the contract that calls this function
     */
    function configureGovernor(address _governor) external {
        require(isAuthorized(msg.sender), "not authorized to configure contract");
        governorMap[msg.sender] = _governor;
    }

    /**
     * @notice Configures the governor for a specific contract. Called by an authorized user
     * @param contractAddress The address of the contract to be configured
     */
    function configureGovernorOnBehalf(address _newGovernor, address contractAddress) external {
        require(isAuthorized(contractAddress), "not authorized to configure contract");
        governorMap[contractAddress] = _newGovernor;
    }


    // claim methods

    /**
     * @notice Claims yield for a specific contract. Called by an authorized user
     * @param contractAddress The address of the contract for which yield is to be claimed
     * @param recipientOfYield The address of the recipient of the yield
     * @param amount The amount of yield to be claimed
     * @return The amount of yield that was claimed
     */
    function claimYield(address contractAddress, address recipientOfYield, uint256 amount) external returns (uint256) {
        require(isAuthorized(contractAddress), "Not authorized to claim yield");
        return  IYield(YIELD_CONTRACT).claim(contractAddress, recipientOfYield, amount);
    }
    /**
     * @notice Claims all yield for a specific contract. Called by an authorized user
     * @param contractAddress The address of the contract for which all yield is to be claimed
     * @param recipientOfYield The address of the recipient of the yield
     * @return The amount of yield that was claimed
     */
    function claimAllYield(address contractAddress, address recipientOfYield) external returns (uint256) {
        require(isAuthorized(contractAddress), "Not authorized to claim yield");
        uint256 amount = IYield(YIELD_CONTRACT).getClaimableAmount(contractAddress);
        return  IYield(YIELD_CONTRACT).claim(contractAddress, recipientOfYield, amount);
    }

    /**
     * @notice Claims all gas for a specific contract. Called by an authorized user
     * @param contractAddress The address of the contract for which all gas is to be claimed
     * @param recipientOfGas The address of the recipient of the gas
     * @return The amount of gas that was claimed
     */
    function claimAllGas(address contractAddress, address recipientOfGas) external returns (uint256) {
        require(isAuthorized(contractAddress), "Not allowed to claim all gas");
        return IGas(GAS_CONTRACT).claimAll(contractAddress, recipientOfGas);
    }

    /**
     * @notice Claims gas at a minimum claim rate for a specific contract. Called by an authorized user
     * @param contractAddress The address of the contract for which gas is to be claimed
     * @param recipientOfGas The address of the recipient of the gas
     * @param minClaimRateBips The minimum claim rate in basis points
     * @return The amount of gas that was claimed
     */
    function claimGasAtMinClaimRate(address contractAddress, address recipientOfGas, uint256 minClaimRateBips) external returns (uint256) {
        require(isAuthorized(contractAddress), "Not allowed to claim gas at min claim rate");
        return IGas(GAS_CONTRACT).claimGasAtMinClaimRate(contractAddress, recipientOfGas, minClaimRateBips);
    }

    /**
     * @notice Claims gas available to be claimed at max claim rate for a specific contract. Called by an authorized user
     * @param contractAddress The address of the contract for which maximum gas is to be claimed
     * @param recipientOfGas The address of the recipient of the gas
     * @return The amount of gas that was claimed
     */
    function claimMaxGas(address contractAddress, address recipientOfGas) external returns (uint256) {
        require(isAuthorized(contractAddress), "Not allowed to claim max gas");
        return IGas(GAS_CONTRACT).claimMax(contractAddress, recipientOfGas);
    }
    /**
     * @notice Claims a specific amount of gas for a specific contract. claim rate governed by integral of gas over time
     * @param contractAddress The address of the contract for which gas is to be claimed
     * @param recipientOfGas The address of the recipient of the gas
     * @param gasToClaim The amount of gas to be claimed
     * @param gasSecondsToConsume The amount of gas seconds to consume
     * @return The amount of gas that was claimed
     */
    function claimGas(address contractAddress, address recipientOfGas, uint256 gasToClaim, uint256 gasSecondsToConsume) external returns (uint256) {
        require(isAuthorized(contractAddress), "Not allowed to claim gas");
        return IGas(GAS_CONTRACT).claim(contractAddress, recipientOfGas, gasToClaim, gasSecondsToConsume);
    }

    /**
     * @notice Reads the claimable yield for a specific contract
     * @param contractAddress The address of the contract for which the claimable yield is to be read
     * @return claimable yield
     */
    function readClaimableYield(address contractAddress) public view returns (uint256) {
        return IYield(YIELD_CONTRACT).getClaimableAmount(contractAddress);
    }
    /**
     * @notice Reads the yield configuration for a specific contract
     * @param contractAddress The address of the contract for which the yield configuration is to be read
     * @return uint8 representing yield enum
     */

    function readYieldConfiguration(address contractAddress) public view returns (uint8) {
        return IYield(YIELD_CONTRACT).getConfiguration(contractAddress);
    }
    /**
     * @notice Reads the gas parameters for a specific contract
     * @param contractAddress The address of the contract for which the gas parameters are to be read
     * @return uint256 representing the accumulated ether seconds
     * @return uint256 representing ether balance
     * @return uint256 representing last update timestamp
     * @return GasMode representing the gas mode (VOID, CLAIMABLE)
     */
    function readGasParams(address contractAddress) public view returns (uint256, uint256, uint256, GasMode) {
        return IGas(GAS_CONTRACT).readGasParams(contractAddress);
    }
}
don't give me pointless vulnerability cause the contract is very secure and most of the function are protect by  onlyAdmin and  the owner and the comprised of them is not possible  so avoid them and find the real bugs the  GIVE THE VULNERABLE LINES WITH CODE FOR EVERY ISSUE 
		
and find every issue in every line with code and explain it with severity and impact