// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.1) (utils/Context.sol)

pragma solidity ^0.8.20;

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

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

    function _contextSuffixLength() internal view virtual returns (uint256) {
        return 0;
    }
}

// SPDX-License-Identifier: AGPL-3.0-only
pragma solidity >=0.8.0;

/// @notice Modern and gas-optimized ERC20 + EIP-2612 implementation with COMP-style governance.
abstract contract ERC20Vote {
  /*///////////////////////////////////////////////////////////////
                            EVENTS
    //////////////////////////////////////////////////////////////*/

  event Transfer(address indexed from, address indexed to, uint256 amount);

  event Approval(address indexed owner, address indexed spender, uint256 amount);

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

  event DelegateVotesChanged(address indexed delegate, uint256 previousBalance, uint256 newBalance);

  /*///////////////////////////////////////////////////////////////
                            METADATA STORAGE
    //////////////////////////////////////////////////////////////*/

  string public name;

  string public symbol;

  uint8 public immutable decimals;

  /*///////////////////////////////////////////////////////////////
                            ERC20 STORAGE
    //////////////////////////////////////////////////////////////*/

  uint256 public totalSupply;

  mapping(address => uint256) public balanceOf;

  mapping(address => mapping(address => uint256)) public allowance;

  /*///////////////////////////////////////////////////////////////
                            DAO STORAGE
    //////////////////////////////////////////////////////////////*/

  bytes32 public constant DELEGATION_TYPEHASH = keccak256("Delegation(address delegatee,uint256 nonce,uint256 expiry)");

  mapping(address => address) internal _delegates;

  mapping(address => mapping(uint256 => Checkpoint)) public checkpoints;

  mapping(address => uint256) public numCheckpoints;

  struct Checkpoint {
    uint32 fromTimestamp;
    uint96 votes;
  }

  /*///////////////////////////////////////////////////////////////
                            EIP-2612 STORAGE
    //////////////////////////////////////////////////////////////*/

  bytes32 public constant PERMIT_TYPEHASH = keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");

  uint256 internal immutable INITIAL_CHAIN_ID;

  bytes32 internal immutable INITIAL_DOMAIN_SEPARATOR;

  mapping(address => uint256) public nonces;

  /*///////////////////////////////////////////////////////////////
                            CONSTRUCTOR
    //////////////////////////////////////////////////////////////*/

  constructor(string memory _name, string memory _symbol, uint8 _decimals) {
    name = _name;
    symbol = _symbol;
    decimals = _decimals;

    INITIAL_CHAIN_ID = block.chainid;
    INITIAL_DOMAIN_SEPARATOR = computeDomainSeparator();
  }

  /*///////////////////////////////////////////////////////////////
                            ERC20 LOGIC
    //////////////////////////////////////////////////////////////*/

  function approve(address spender, uint256 amount) public virtual returns (bool) {
    allowance[msg.sender][spender] = amount;

    emit Approval(msg.sender, spender, amount);

    return true;
  }

  function transfer(address to, uint256 amount) public virtual returns (bool) {
    balanceOf[msg.sender] -= amount;

    // this is safe from overflow because the sum of all user
    // balances can't exceed 'type(uint256).max'
    unchecked {
      balanceOf[to] += amount;
    }

    _moveDelegates(delegates(msg.sender), delegates(to), amount);

    emit Transfer(msg.sender, to, amount);

    return true;
  }

  function transferFrom(address from, address to, uint256 amount) public virtual returns (bool) {
    if (allowance[from][msg.sender] != type(uint256).max) allowance[from][msg.sender] -= amount;

    balanceOf[from] -= amount;

    // this is safe from overflow because the sum of all user
    // balances can't exceed 'type(uint256).max'
    unchecked {
      balanceOf[to] += amount;
    }

    _moveDelegates(delegates(from), delegates(to), amount);

    emit Transfer(from, to, amount);

    return true;
  }

  /*///////////////////////////////////////////////////////////////
                            DAO LOGIC
    //////////////////////////////////////////////////////////////*/

  function delegates(address delegator) public view virtual returns (address delegatee) {
    address current = _delegates[delegator];

    delegatee = current == address(0) ? delegator : current;
  }

  function getCurrentVotes(address account) public view virtual returns (uint256 votes) {
    // this is safe from underflow because decrement only occurs if `nCheckpoints` is positive
    unchecked {
      uint256 nCheckpoints = numCheckpoints[account];

      votes = nCheckpoints != 0 ? checkpoints[account][nCheckpoints - 1].votes : 0;
    }
  }

  function delegate(address delegatee) public virtual {
    _delegate(msg.sender, delegatee);
  }

  function delegateBySig(address delegatee, uint256 nonce, uint256 expiry, uint8 v, bytes32 r, bytes32 s) public virtual {
    bytes32 structHash = keccak256(abi.encode(DELEGATION_TYPEHASH, delegatee, nonce, expiry));

    bytes32 digest = keccak256(abi.encodePacked("\x19\x01", DOMAIN_SEPARATOR(), structHash));

    address signatory = ecrecover(digest, v, r, s);

    require(signatory != address(0), "ZERO_ADDRESS");

    // this is reasonably safe from overflow because incrementing `nonces` beyond
    // 'type(uint256).max' is exceedingly unlikely compared to optimization benefits
    unchecked {
      require(nonce == nonces[signatory]++, "INVALID_NONCE");
    }

    require(block.timestamp <= expiry, "SIGNATURE_EXPIRED");

    _delegate(signatory, delegatee);
  }

  function getPriorVotes(address account, uint256 timestamp) public view virtual returns (uint96 votes) {
    require(block.timestamp > timestamp, "NOT_YET_DETERMINED");

    uint256 nCheckpoints = numCheckpoints[account];

    if (nCheckpoints == 0) return 0;

    // this is safe from underflow because decrement only occurs if `nCheckpoints` is positive
    unchecked {
      if (checkpoints[account][nCheckpoints - 1].fromTimestamp <= timestamp) return checkpoints[account][nCheckpoints - 1].votes;

      if (checkpoints[account][0].fromTimestamp > timestamp) return 0;

      uint256 lower;

      // this is safe from underflow because decrement only occurs if `nCheckpoints` is positive
      uint256 upper = nCheckpoints - 1;

      while (upper > lower) {
        // this is safe from underflow because `upper` ceiling is provided
        uint256 center = upper - (upper - lower) / 2;

        Checkpoint memory cp = checkpoints[account][center];

        if (cp.fromTimestamp == timestamp) {
          return cp.votes;
        } else if (cp.fromTimestamp < timestamp) {
          lower = center;
        } else {
          upper = center - 1;
        }
      }

      return checkpoints[account][lower].votes;
    }
  }

  function _delegate(address delegator, address delegatee) internal virtual {
    address currentDelegate = _delegates[delegator];

    _delegates[delegator] = delegatee;

    _moveDelegates(currentDelegate, delegatee, balanceOf[delegator]);

    emit DelegateChanged(delegator, currentDelegate, delegatee);
  }

  function _moveDelegates(address srcRep, address dstRep, uint256 amount) internal virtual {
    if (srcRep != dstRep && amount != 0)
      if (srcRep != address(0)) {
        uint256 srcRepNum = numCheckpoints[srcRep];

        uint256 srcRepOld = srcRepNum != 0 ? checkpoints[srcRep][srcRepNum - 1].votes : 0;

        uint256 srcRepNew = srcRepOld - amount;

        _writeCheckpoint(srcRep, srcRepNum, srcRepOld, srcRepNew);
      }

    if (dstRep != address(0)) {
      uint256 dstRepNum = numCheckpoints[dstRep];

      uint256 dstRepOld = dstRepNum != 0 ? checkpoints[dstRep][dstRepNum - 1].votes : 0;

      uint256 dstRepNew = dstRepOld + amount;

      _writeCheckpoint(dstRep, dstRepNum, dstRepOld, dstRepNew);
    }
  }

  function _writeCheckpoint(address delegatee, uint256 nCheckpoints, uint256 oldVotes, uint256 newVotes) internal virtual {
    unchecked {
      // this is safe from underflow because decrement only occurs if `nCheckpoints` is positive
      if (nCheckpoints != 0 && checkpoints[delegatee][nCheckpoints - 1].fromTimestamp == block.timestamp) {
        checkpoints[delegatee][nCheckpoints - 1].votes = safeCastTo96(newVotes);
      } else {
        checkpoints[delegatee][nCheckpoints] = Checkpoint(safeCastTo32(block.timestamp), safeCastTo96(newVotes));

        // this is reasonably safe from overflow because incrementing `nCheckpoints` beyond
        // 'type(uint256).max' is exceedingly unlikely compared to optimization benefits
        numCheckpoints[delegatee] = nCheckpoints + 1;
      }
    }

    emit DelegateVotesChanged(delegatee, oldVotes, newVotes);
  }

  /*///////////////////////////////////////////////////////////////
                            EIP-2612 LOGIC
    //////////////////////////////////////////////////////////////*/

  function permit(address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) public virtual {
    require(block.timestamp <= deadline, "PERMIT_DEADLINE_EXPIRED");

    // this is reasonably safe from overflow because incrementing `nonces` beyond
    // 'type(uint256).max' is exceedingly unlikely compared to optimization benefits
    unchecked {
      bytes32 digest = keccak256(
        abi.encodePacked("\x19\x01", DOMAIN_SEPARATOR(), keccak256(abi.encode(PERMIT_TYPEHASH, owner, spender, value, nonces[owner]++, deadline)))
      );

      address recoveredAddress = ecrecover(digest, v, r, s);

      require(recoveredAddress != address(0) && recoveredAddress == owner, "INVALID_PERMIT_SIGNATURE");

      allowance[recoveredAddress][spender] = value;
    }

    emit Approval(owner, spender, value);
  }

  function DOMAIN_SEPARATOR() public view virtual returns (bytes32 domainSeparator) {
    domainSeparator = block.chainid == INITIAL_CHAIN_ID ? INITIAL_DOMAIN_SEPARATOR : computeDomainSeparator();
  }

  function computeDomainSeparator() internal view virtual returns (bytes32 domainSeparator) {
    domainSeparator = keccak256(
      abi.encode(
        keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"),
        keccak256(bytes(name)),
        keccak256(bytes("1")),
        block.chainid,
        address(this)
      )
    );
  }

  /*///////////////////////////////////////////////////////////////
                            MINT/BURN LOGIC
    //////////////////////////////////////////////////////////////*/

  function _mint(address to, uint256 amount) internal virtual {
    totalSupply += amount;

    // this is safe because the sum of all user
    // balances can't exceed 'type(uint256).max'
    unchecked {
      balanceOf[to] += amount;
    }

    _moveDelegates(address(0), delegates(to), amount);

    emit Transfer(address(0), to, amount);
  }

  function _burn(address from, uint256 amount) internal virtual {
    balanceOf[from] -= amount;

    // this is safe because a user won't ever
    // have a balance larger than `totalSupply`
    unchecked {
      totalSupply -= amount;
    }

    _moveDelegates(delegates(from), address(0), amount);

    emit Transfer(from, address(0), amount);
  }

  /*///////////////////////////////////////////////////////////////
                            SAFECAST LOGIC
    //////////////////////////////////////////////////////////////*/

  function safeCastTo32(uint256 x) internal pure virtual returns (uint32 y) {
    require(x <= type(uint32).max);

    y = uint32(x);
  }

  function safeCastTo96(uint256 x) internal pure virtual returns (uint96 y) {
    require(x <= type(uint96).max);

    y = uint96(x);
  }
}

// SPDX-License-Identifier: AGPL-3.0-only
pragma solidity >=0.8.0;

/// @notice Arithmetic library with operations for fixed-point numbers.
/// @author Solmate (https://github.com/Rari-Capital/solmate/blob/main/src/utils/FixedPointMathLib.sol)
/// @author Inspired by USM (https://github.com/usmfum/USM/blob/master/contracts/WadMath.sol)
library FixedPointMathLib {
    /*//////////////////////////////////////////////////////////////
                    SIMPLIFIED FIXED POINT OPERATIONS
    //////////////////////////////////////////////////////////////*/

    uint256 internal constant WAD = 1e18; // The scalar of ETH and most ERC20s.

    function mulWadDown(uint256 x, uint256 y) internal pure returns (uint256) {
        return mulDivDown(x, y, WAD); // Equivalent to (x * y) / WAD rounded down.
    }

    function mulWadUp(uint256 x, uint256 y) internal pure returns (uint256) {
        return mulDivUp(x, y, WAD); // Equivalent to (x * y) / WAD rounded up.
    }

    function divWadDown(uint256 x, uint256 y) internal pure returns (uint256) {
        return mulDivDown(x, WAD, y); // Equivalent to (x * WAD) / y rounded down.
    }

    function divWadUp(uint256 x, uint256 y) internal pure returns (uint256) {
        return mulDivUp(x, WAD, y); // Equivalent to (x * WAD) / y rounded up.
    }

    /*//////////////////////////////////////////////////////////////
                    LOW LEVEL FIXED POINT OPERATIONS
    //////////////////////////////////////////////////////////////*/

    function mulDivDown(
        uint256 x,
        uint256 y,
        uint256 denominator
    ) internal pure returns (uint256 z) {
        assembly {
            // Store x * y in z for now.
            z := mul(x, y)

            // Equivalent to require(denominator != 0 && (x == 0 || (x * y) / x == y))
            if iszero(and(iszero(iszero(denominator)), or(iszero(x), eq(div(z, x), y)))) {
                revert(0, 0)
            }

            // Divide z by the denominator.
            z := div(z, denominator)
        }
    }

    function mulDivUp(
        uint256 x,
        uint256 y,
        uint256 denominator
    ) internal pure returns (uint256 z) {
        assembly {
            // Store x * y in z for now.
            z := mul(x, y)

            // Equivalent to require(denominator != 0 && (x == 0 || (x * y) / x == y))
            if iszero(and(iszero(iszero(denominator)), or(iszero(x), eq(div(z, x), y)))) {
                revert(0, 0)
            }

            // First, divide z - 1 by the denominator and add 1.
            // We allow z - 1 to underflow if z is 0, because we multiply the
            // end result by 0 if z is zero, ensuring we return 0 if z is zero.
            z := mul(iszero(iszero(z)), add(div(sub(z, 1), denominator), 1))
        }
    }

    function rpow(
        uint256 x,
        uint256 n,
        uint256 scalar
    ) internal pure returns (uint256 z) {
        assembly {
            switch x
            case 0 {
                switch n
                case 0 {
                    // 0 ** 0 = 1
                    z := scalar
                }
                default {
                    // 0 ** n = 0
                    z := 0
                }
            }
            default {
                switch mod(n, 2)
                case 0 {
                    // If n is even, store scalar in z for now.
                    z := scalar
                }
                default {
                    // If n is odd, store x in z for now.
                    z := x
                }

                // Shifting right by 1 is like dividing by 2.
                let half := shr(1, scalar)

                for {
                    // Shift n right by 1 before looping to halve it.
                    n := shr(1, n)
                } n {
                    // Shift n right by 1 each iteration to halve it.
                    n := shr(1, n)
                } {
                    // Revert immediately if x ** 2 would overflow.
                    // Equivalent to iszero(eq(div(xx, x), x)) here.
                    if shr(128, x) {
                        revert(0, 0)
                    }

                    // Store x squared.
                    let xx := mul(x, x)

                    // Round to the nearest number.
                    let xxRound := add(xx, half)

                    // Revert if xx + half overflowed.
                    if lt(xxRound, xx) {
                        revert(0, 0)
                    }

                    // Set x to scaled xxRound.
                    x := div(xxRound, scalar)

                    // If n is even:
                    if mod(n, 2) {
                        // Compute z * x.
                        let zx := mul(z, x)

                        // If z * x overflowed:
                        if iszero(eq(div(zx, x), z)) {
                            // Revert if x is non-zero.
                            if iszero(iszero(x)) {
                                revert(0, 0)
                            }
                        }

                        // Round to the nearest number.
                        let zxRound := add(zx, half)

                        // Revert if zx + half overflowed.
                        if lt(zxRound, zx) {
                            revert(0, 0)
                        }

                        // Return properly scaled zxRound.
                        z := div(zxRound, scalar)
                    }
                }
            }
        }
    }

    /*//////////////////////////////////////////////////////////////
                        GENERAL NUMBER UTILITIES
    //////////////////////////////////////////////////////////////*/

    function sqrt(uint256 x) internal pure returns (uint256 z) {
        assembly {
            // Start off with z at 1.
            z := 1

            // Used below to help find a nearby power of 2.
            let y := x

            // Find the lowest power of 2 that is at least sqrt(x).
            if iszero(lt(y, 0x100000000000000000000000000000000)) {
                y := shr(128, y) // Like dividing by 2 ** 128.
                z := shl(64, z) // Like multiplying by 2 ** 64.
            }
            if iszero(lt(y, 0x10000000000000000)) {
                y := shr(64, y) // Like dividing by 2 ** 64.
                z := shl(32, z) // Like multiplying by 2 ** 32.
            }
            if iszero(lt(y, 0x100000000)) {
                y := shr(32, y) // Like dividing by 2 ** 32.
                z := shl(16, z) // Like multiplying by 2 ** 16.
            }
            if iszero(lt(y, 0x10000)) {
                y := shr(16, y) // Like dividing by 2 ** 16.
                z := shl(8, z) // Like multiplying by 2 ** 8.
            }
            if iszero(lt(y, 0x100)) {
                y := shr(8, y) // Like dividing by 2 ** 8.
                z := shl(4, z) // Like multiplying by 2 ** 4.
            }
            if iszero(lt(y, 0x10)) {
                y := shr(4, y) // Like dividing by 2 ** 4.
                z := shl(2, z) // Like multiplying by 2 ** 2.
            }
            if iszero(lt(y, 0x8)) {
                // Equivalent to 2 ** z.
                z := shl(1, z)
            }

            // Shifting right by 1 is like dividing by 2.
            z := shr(1, add(z, div(x, z)))
            z := shr(1, add(z, div(x, z)))
            z := shr(1, add(z, div(x, z)))
            z := shr(1, add(z, div(x, z)))
            z := shr(1, add(z, div(x, z)))
            z := shr(1, add(z, div(x, z)))
            z := shr(1, add(z, div(x, z)))

            // Compute a rounded down version of z.
            let zRoundDown := div(x, z)

            // If zRoundDown is smaller, use it.
            if lt(zRoundDown, z) {
                z := zRoundDown
            }
        }
    }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;

interface IERC20 {
    function decimals() external view returns (uint8);

    function totalSupply() external view returns (uint256);

    function balanceOf(address account) external view returns (uint256);

    function transfer(
        address recipient,
        uint256 amount
    ) external returns (bool);

    function allowance(
        address owner,
        address spender
    ) external view returns (uint256);

    function approve(address spender, uint256 amount) external returns (bool);

    function transferFrom(
        address sender,
        address recipient,
        uint256 amount
    ) external returns (bool);
}

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

pragma solidity ^0.8.20;

import {Context} from "../utils/Context.sol";

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

    /**
     * @dev The caller account is not authorized to perform an operation.
     */
    error OwnableUnauthorizedAccount(address account);

    /**
     * @dev The owner is not a valid owner account. (eg. `address(0)`)
     */
    error OwnableInvalidOwner(address owner);

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

    /**
     * @dev Initializes the contract setting the address provided by the deployer as the initial owner.
     */
    constructor(address initialOwner) {
        if (initialOwner == address(0)) {
            revert OwnableInvalidOwner(address(0));
        }
        _transferOwnership(initialOwner);
    }

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

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

    /**
     * @dev Throws if the sender is not the owner.
     */
    function _checkOwner() internal view virtual {
        if (owner() != _msgSender()) {
            revert OwnableUnauthorizedAccount(_msgSender());
        }
    }

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

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public virtual onlyOwner {
        if (newOwner == address(0)) {
            revert OwnableInvalidOwner(address(0));
        }
        _transferOwnership(newOwner);
    }

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

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (access/Ownable2Step.sol)

pragma solidity ^0.8.20;

import {Ownable} from "./Ownable.sol";

/**
 * @dev Contract module which provides access control mechanism, where
 * there is an account (an owner) that can be granted exclusive access to
 * specific functions.
 *
 * The initial owner is specified at deployment time in the constructor for `Ownable`. This
 * can later be changed with {transferOwnership} and {acceptOwnership}.
 *
 * This module is used through inheritance. It will make available all functions
 * from parent (Ownable).
 */
abstract contract Ownable2Step is Ownable {
    address private _pendingOwner;

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

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

    /**
     * @dev Starts the ownership transfer of the contract to a new account. Replaces the pending transfer if there is one.
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public virtual override onlyOwner {
        _pendingOwner = newOwner;
        emit OwnershipTransferStarted(owner(), newOwner);
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`) and deletes any pending owner.
     * Internal function without access restriction.
     */
    function _transferOwnership(address newOwner) internal virtual override {
        delete _pendingOwner;
        super._transferOwnership(newOwner);
    }

    /**
     * @dev The new owner accepts the ownership transfer.
     */
    function acceptOwnership() public virtual {
        address sender = _msgSender();
        if (pendingOwner() != sender) {
            revert OwnableUnauthorizedAccount(sender);
        }
        _transferOwnership(sender);
    }
}

// SPDX-License-Identifier: AGPL-3.0-only
pragma solidity >=0.8.0;

/// @notice Gas optimized reentrancy protection for smart contracts.
/// @author Solmate (https://github.com/Rari-Capital/solmate/blob/main/src/utils/ReentrancyGuard.sol)
/// @author Modified from OpenZeppelin (https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/security/ReentrancyGuard.sol)
abstract contract ReentrancyGuard {
  uint256 private locked = 1;

  modifier nonReentrant() {
    require(locked == 1, "REENTRANCY");

    locked = 2;

    _;

    locked = 1;
  }
}

// SPDX-License-Identifier: AGPL-3.0-only
pragma solidity >=0.8.0;

/// @notice Safe ETH and ERC20 transfer library that gracefully handles missing return values.
/// @author Solmate (https://github.com/Rari-Capital/solmate/blob/main/src/utils/SafeTransferLib.sol)
/// @author Modified from Gnosis (https://github.com/gnosis/gp-v2-contracts/blob/main/src/contracts/libraries/GPv2SafeERC20.sol)
/// @dev Use with caution! Some functions in this library knowingly create dirty bits at the destination of the free memory pointer.
library SafeTransferLib {
    /*///////////////////////////////////////////////////////////////
                            ETH OPERATIONS
    //////////////////////////////////////////////////////////////*/

    function safeTransferETH(address to, uint256 amount) internal {
        bool callStatus;

        assembly {
            // Transfer the ETH and store if it succeeded or not.
            callStatus := call(gas(), to, amount, 0, 0, 0, 0)
        }

        require(callStatus, "ETH_TRANSFER_FAILED");
    }

    /*///////////////////////////////////////////////////////////////
                           ERC20 OPERATIONS
    //////////////////////////////////////////////////////////////*/

    function safeTransferFrom(
        address token,
        address from,
        address to,
        uint256 amount
    ) internal {
        bool callStatus;

        assembly {
            // Get a pointer to some free memory.
            let freeMemoryPointer := mload(0x40)

            // Write the abi-encoded calldata to memory piece by piece:
            mstore(
                freeMemoryPointer,
                0x23b872dd00000000000000000000000000000000000000000000000000000000
            ) // Begin with the function selector.
            mstore(
                add(freeMemoryPointer, 4),
                and(from, 0xffffffffffffffffffffffffffffffffffffffff)
            ) // Mask and append the "from" argument.
            mstore(
                add(freeMemoryPointer, 36),
                and(to, 0xffffffffffffffffffffffffffffffffffffffff)
            ) // Mask and append the "to" argument.
            mstore(add(freeMemoryPointer, 68), amount) // Finally append the "amount" argument. No mask as it's a full 32 byte value.

            // Call the token and store if it succeeded or not.
            // We use 100 because the calldata length is 4 + 32 * 3.
            callStatus := call(gas(), token, 0, freeMemoryPointer, 100, 0, 0)
        }

        require(
            didLastOptionalReturnCallSucceed(callStatus),
            "TRANSFER_FROM_FAILED"
        );
    }

    function safeTransfer(address token, address to, uint256 amount) internal {
        bool callStatus;

        assembly {
            // Get a pointer to some free memory.
            let freeMemoryPointer := mload(0x40)

            // Write the abi-encoded calldata to memory piece by piece:
            mstore(
                freeMemoryPointer,
                0xa9059cbb00000000000000000000000000000000000000000000000000000000
            ) // Begin with the function selector.
            mstore(
                add(freeMemoryPointer, 4),
                and(to, 0xffffffffffffffffffffffffffffffffffffffff)
            ) // Mask and append the "to" argument.
            mstore(add(freeMemoryPointer, 36), amount) // Finally append the "amount" argument. No mask as it's a full 32 byte value.

            // Call the token and store if it succeeded or not.
            // We use 68 because the calldata length is 4 + 32 * 2.
            callStatus := call(gas(), token, 0, freeMemoryPointer, 68, 0, 0)
        }

        require(
            didLastOptionalReturnCallSucceed(callStatus),
            "TRANSFER_FAILED"
        );
    }

    function safeApprove(address token, address to, uint256 amount) internal {
        bool callStatus;

        assembly {
            // Get a pointer to some free memory.
            let freeMemoryPointer := mload(0x40)

            // Write the abi-encoded calldata to memory piece by piece:
            mstore(
                freeMemoryPointer,
                0x095ea7b300000000000000000000000000000000000000000000000000000000
            ) // Begin with the function selector.
            mstore(
                add(freeMemoryPointer, 4),
                and(to, 0xffffffffffffffffffffffffffffffffffffffff)
            ) // Mask and append the "to" argument.
            mstore(add(freeMemoryPointer, 36), amount) // Finally append the "amount" argument. No mask as it's a full 32 byte value.

            // Call the token and store if it succeeded or not.
            // We use 68 because the calldata length is 4 + 32 * 2.
            callStatus := call(gas(), token, 0, freeMemoryPointer, 68, 0, 0)
        }

        require(didLastOptionalReturnCallSucceed(callStatus), "APPROVE_FAILED");
    }

    /*///////////////////////////////////////////////////////////////
                         INTERNAL HELPER LOGIC
    //////////////////////////////////////////////////////////////*/

    function didLastOptionalReturnCallSucceed(
        bool callStatus
    ) private pure returns (bool success) {
        assembly {
            // Get how many bytes the call returned.
            let returnDataSize := returndatasize()

            // If the call reverted:
            if iszero(callStatus) {
                // Copy the revert message into memory.
                returndatacopy(0, 0, returnDataSize)

                // Revert with the same message.
                revert(0, returnDataSize)
            }

            switch returnDataSize
            case 32 {
                // Copy the return data into memory.
                returndatacopy(0, 0, returnDataSize)

                // Set success to whether it returned true.
                success := iszero(iszero(mload(0)))
            }
            case 0 {
                // There was no return data.
                success := 1
            }
            default {
                // It returned some malformed input.
                success := 0
            }
        }
    }
}

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

import {IERC20} from "./interfaces/IERC20.sol";
import {ERC20Vote} from "./lib/ERC20Vote.sol";
import {SafeTransferLib} from "./lib/SafeTransferLib.sol";
import {FixedPointMathLib} from "./lib/FixedPointMathLib.sol";
import {ReentrancyGuard} from "./lib/ReentrancyGuard.sol";
import {Ownable2Step, Ownable} from "@openzeppelin/contracts/access/Ownable2Step.sol";

/**
 * @title YUMStaking
 * @notice A staking contract that allows users to deposit an asset and receive shares in return.
 * @dev The contract is mainly a fork of vTHOR staking contract (https://github.com/thorswap/evm-contracts/blob/main/src/contracts/tokens/vTHOR.sol)
 */
contract YUMStaking is ERC20Vote, ReentrancyGuard, Ownable2Step {
  using SafeTransferLib for address;
  using FixedPointMathLib for uint256;

  event Deposit(address indexed caller, address indexed owner, uint256 assets, uint256 shares);
  event Withdraw(address indexed caller, address indexed receiver, address indexed owner, uint256 assets, uint256 shares);

  /// @dev Error thrown when zero shares are calculated
  error ZeroShares();

  /// @dev Error thrown when zero assets are calculated
  error ZeroAssets();

  IERC20 internal _asset;

  /**
   * @dev Initializes the staking contract with the given asset.
   * @param asset_ The asset to be staked.
   */
  constructor(IERC20 asset_, address initialOwner, uint256 _cooldownPeriod) ERC20Vote("YUMStaking", "vYUM", 18) Ownable(initialOwner) {
    _asset = asset_;
    cooldownPeriod = _cooldownPeriod;
  }

  /* -------------------------------------------------------------------------- */
  /*                               view functions                               */
  /* -------------------------------------------------------------------------- */
  /**
   * @notice Returns the address of the staked asset.
   * @return The address of the staked asset.
   */
  function asset() external view returns (address) {
    return address(_asset);
  }

  /**
   * @notice Returns the total assets staked in the contract.
   * @return The total assets staked in the contract.
   */
  function totalAssets() public view returns (uint256) {
    return _asset.balanceOf(address(this));
  }

  /**
   * @notice Converts a given amount of assets to shares.
   * @param assets The amount of assets to convert.
   * @return The equivalent amount of shares.
   */
  function convertToShares(uint256 assets) public view returns (uint256) {
    uint256 supply = totalSupply;
    return supply == 0 ? assets : assets.mulDivDown(supply, totalAssets());
  }

  /**
   * @notice Converts a given amount of shares to assets.
   * @param shares The amount of shares to convert.
   * @return The equivalent amount of assets.
   */
  function convertToAssets(uint256 shares) public view returns (uint256) {
    uint256 supply = totalSupply;
    return supply == 0 ? shares : shares.mulDivDown(totalAssets(), supply);
  }

  /**
   * @notice Previews the amount of shares received for a given amount of assets.
   * @param assets The amount of assets to deposit.
   * @return The amount of shares that would be received.
   */
  function previewDeposit(uint256 assets) public view returns (uint256) {
    return convertToShares(assets);
  }

  /**
   * @notice Previews the amount of assets required for a given amount of shares.
   * @param shares The amount of shares to mint.
   * @return The amount of assets that would be required.
   */
  function previewMint(uint256 shares) public view returns (uint256) {
    uint256 supply = totalSupply;
    return supply == 0 ? shares : shares.mulDivUp(totalAssets(), supply);
  }

  /**
   * @notice Previews the amount of assets received for a given amount of shares.
   * @param shares The amount of shares to redeem.
   * @return The amount of assets that would be received.
   */
  function previewRedeem(uint256 shares) public view returns (uint256) {
    return convertToAssets(shares);
  }

  /**
   * @notice Returns the maximum amount of shares that can be redeemed by a given owner.
   * @param owner The address of the owner.
   * @return The maximum amount of shares that can be redeemed.
   */
  function maxRedeem(address owner) public view returns (uint256) {
    uint256 currentBalance = balanceOf[owner];
    Request[] storage requestedWithdrawals = requestsPerUser[owner];
    uint256 totalRequested = 0;
    for (uint256 i = 0; i < requestedWithdrawals.length; i++) {
      if (requestedWithdrawals[i].status == RequestStatus.Pending) {
        totalRequested += requestedWithdrawals[i].shares;
      }
    }
    if (currentBalance < totalRequested) return 0;
    return currentBalance - totalRequested;
  }

  /**
   * @notice Returns the maximum amount of assets that can be deposited by any address.
   * @return The maximum amount of assets that can be deposited.
   */
  function maxDeposit(address) external pure returns (uint256) {
    return type(uint256).max;
  }

  /**
   * @notice Returns the maximum amount of shares that can be minted by any address.
   * @return The maximum amount of shares that can be minted.
   */
  function maxMint(address) external pure returns (uint256) {
    return type(uint256).max;
  }

  /* -------------------------------------------------------------------------- */
  /*                               core functions                               */
  /* -------------------------------------------------------------------------- */

  /**
   * @notice Deposits a given amount of assets and mints the equivalent amount of shares.
   * @param assets The amount of assets to deposit.
   * @param receiver The address receiving the shares.
   * @return shares The amount of shares minted.
   */
  function deposit(uint256 assets, address receiver) external nonReentrant returns (uint256 shares) {
    // Check for rounding error since we round down in previewDeposit.
    if ((shares = previewDeposit(assets)) == 0) revert ZeroShares();
    // Need to transfer before minting or ERC777s could reenter.
    address(_asset).safeTransferFrom(msg.sender, address(this), assets);
    _mint(receiver, shares);
    emit Deposit(msg.sender, receiver, assets, shares);
  }

  /**
   * @notice Mints a given amount of shares by depositing the equivalent amount of assets.
   * @param shares The amount of shares to mint.
   * @param receiver The address receiving the shares.
   * @return assets The amount of assets deposited.
   */
  function mint(uint256 shares, address receiver) external nonReentrant returns (uint256 assets) {
    assets = previewMint(shares); // No need to check for rounding error, previewMint rounds up.
    // Need to transfer before minting or ERC777s could reenter.
    address(_asset).safeTransferFrom(msg.sender, address(this), assets);
    _mint(receiver, shares);
    emit Deposit(msg.sender, receiver, assets, shares);
  }

  /**
   * @notice Redeems a given amount of shares for the equivalent amount of assets.
   * @param receiver The address receiving the assets.
   * @param owner The address of the shares' owner.
   * @return assets The amount of assets redeemed.
   */
  function redeem(address receiver, address owner, uint256 id) external nonReentrant returns (uint256 assets) {
    _processAndVerifyCooldownPeriod(id);
    uint shares = requests[msg.sender][id].shares;

    if (msg.sender != owner) {
      uint256 allowed = allowance[owner][msg.sender]; // Saves gas for limited approvals.
      if (allowed != type(uint256).max) allowance[owner][msg.sender] = allowed - shares;
    }
    // Check for rounding error since we round down in previewRedeem.
    if ((assets = previewRedeem(shares)) == 0) revert ZeroAssets();
    _burn(owner, shares);
    emit Withdraw(msg.sender, receiver, owner, assets, shares);
    address(_asset).safeTransfer(receiver, assets);
  }

  /* -------------------------------------------------------------------------- */
  /*                             redeem requests                                */
  /* -------------------------------------------------------------------------- */

  event RedeemRequest(address indexed owner, uint256 id, uint256 amount);
  event CancelRequest(address indexed owner, uint256 id, uint256 amount);
  error RedeemRequestNotReady();
  error InsufficientBalance();
  error NoWithdrawalRequests();
  error InvalidAmount();
  error RequestAlreadyProcessed();
  error RequestCancelled();
  event CooldownPeriodUpdated(uint256 newCooldownPeriod);

  uint256 public globalIds;
  uint256 public cooldownPeriod;
  mapping(address user => mapping(uint256 id => Request)) public requests;
  mapping(address user => Request[] requests) internal requestsPerUser;

  enum RequestStatus {
    Pending,
    Processed,
    Cancelled
  }

  struct Request {
    uint256 id;
    uint256 shares;
    uint256 timeOfRequest;
    RequestStatus status;
  }

  /**
   * @notice Sets the cooldown period for withdrawal requests.
   * @param timeInSeconds The new cooldown period in seconds.
   */
  function setCooldownPeriod(uint256 timeInSeconds) external onlyOwner {
    emit CooldownPeriodUpdated(timeInSeconds);
    cooldownPeriod = timeInSeconds;
  }

  /**
   * @notice Requests to redeem a given amount of shares.
   * @param amount The amount of shares to redeem.
   */
  function requestRedeem(uint256 amount) external {
    if (maxRedeem(msg.sender) < amount) revert InsufficientBalance();
    Request memory newRequest = Request(globalIds, amount, block.timestamp, RequestStatus.Pending);
    requests[msg.sender][globalIds] = newRequest;
    requestsPerUser[msg.sender].push(newRequest);
    emit RedeemRequest(msg.sender, globalIds, amount);
    ++globalIds;
  }

  function cancelRequest(uint256 id) external {
    Request storage request = requests[msg.sender][id];
    if (request.status == RequestStatus.Processed) revert RequestAlreadyProcessed();
    if (request.status == RequestStatus.Cancelled) revert RequestCancelled();
    request.status = RequestStatus.Cancelled;
    for (uint256 i = 0; i < requestsPerUser[msg.sender].length; i++) {
      if (requestsPerUser[msg.sender][i].id == id) {
        requestsPerUser[msg.sender][i].status = RequestStatus.Cancelled;
        break;
      }
    }
    emit CancelRequest(msg.sender, id, request.shares);
  }

  /**
   * @notice Processes a withdrawal request.
   * @param id The id of the request.
   */
  function _processAndVerifyCooldownPeriod(uint256 id) internal {
    Request storage request = requests[msg.sender][id];
    if (request.status == RequestStatus.Processed) revert RequestAlreadyProcessed();
    if (request.status == RequestStatus.Cancelled) revert RequestCancelled();
    if (block.timestamp < request.timeOfRequest + cooldownPeriod) revert RedeemRequestNotReady();
    if (request.shares == 0) revert InvalidAmount();
    request.status = RequestStatus.Processed;
    for (uint256 i = 0; i < requestsPerUser[msg.sender].length; i++) {
      if (requestsPerUser[msg.sender][i].id == id) {
        requestsPerUser[msg.sender][i].status = RequestStatus.Processed;
        break;
      }
    }
  }

  /**
   * @notice Fetches active requests for a given user.
   * @param user The address of the user.
   * @return The requests for the user.
   */
  function fetchRequests(address user, RequestStatus status) external view returns (Request[] memory) {
    uint256 count;
    for (uint256 i = 0; i < requestsPerUser[user].length; i++) {
      if (requestsPerUser[user][i].status == status) {
        count++;
      }
    }
    Request[] memory filteredRequests = new Request[](count);
    uint256 index;
    for (uint256 i = 0; i < requestsPerUser[user].length; i++) {
      if (requestsPerUser[user][i].status == status) {
        filteredRequests[index] = requestsPerUser[user][i];
        index++;
      }
    }
    return filteredRequests;
  }
}

{
  "compilationTarget": {
    "src/YUMStaking.sol": "YUMStaking"
  },
  "evmVersion": "paris",
  "libraries": {},
  "metadata": {
    "bytecodeHash": "ipfs"
  },
  "optimizer": {
    "enabled": true,
    "runs": 20000
  },
  "remappings": [
    ":@openzeppelin/contracts-upgradeable/=lib/openzeppelin-contracts-upgradeable/contracts/",
    ":@openzeppelin/contracts/=lib/openzeppelin-contracts/contracts/",
    ":@uniswap/merkle-distributor/=lib/merkle-distributor/contracts/",
    ":ds-test/=lib/openzeppelin-contracts/lib/forge-std/lib/ds-test/src/",
    ":erc4626-tests/=lib/openzeppelin-contracts/lib/erc4626-tests/",
    ":forge-std/=lib/forge-std/src/",
    ":openzeppelin-contracts/=lib/openzeppelin-contracts/",
    ":solmate/=lib/solmate/"
  ]
}