Contract Address Details

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

import "./TransferHelper.sol";
import "./EnumerableSet.sol";
import "./ReentrancyGuard.sol";

interface IElectroSwapPair {
    function token0() external view returns (address);
    function token1() external view returns (address);
}

interface IElectroSwapFactory {
    function getPair(address tokenA, address tokenB) external view returns (address);
}

interface IMigrator {
    function migrate(address pairAddress, address owner, uint256 amountToMigrate, uint256 lockCreated, uint256 lockDuration) external returns (bool);
}

contract ElectroSwapLockerV2 is ReentrancyGuard {

    using EnumerableSet for EnumerableSet.AddressSet;

    event LiquidityLocked(address indexed owner, address indexed pair, uint amount, uint duration, uint indexed lockID);
    event LiquidityWithdrawn(address indexed owner, address indexed pair, uint amount, uint lockID);
    event LockTransferred(uint indexed lockID, address indexed previousOwner, address indexed newOwner);
    event LockSplit(uint indexed originalLockID, uint indexed newLockID);
    event LockIncreased(uint indexed lockID, uint existingAmount, uint existingDuration, uint newAmount, uint newDuration);
    event LockMigrated(uint indexed lockID);

    struct LockInfo {
        uint lockID; // Unique ID for this lock
        address pair; // Address of the liquidity pair that is locked
        address owner; // Address that is permitted to withdraw liquidity
        uint initial; // Initial number of tokens locked
        uint amount; // Current number of tokens locked
        uint created; // Timestamp in seconds when the lock was created
        uint duration; // Duration of lock in seconds from time of creation
    }

    struct Fees {
        uint etnFlatFee; // Amount of ETN paid as lock creation fee to stop spam
        uint boltFlatFee; // Amount of BOLT to be burned when paying lock creation fee in BOLT
        uint lpPercentFee; // Platform fee as a percentage of locked ElectroSwap LP tokens
    }

    modifier onlyTeam() {
        require(msg.sender == teamWallet, "Only contract owner can call this function");
        _;
    }

    address payable teamWallet;
    address public boltAddress;
    address private deadAddress = address(0x000000000000000000000000000000000000dEaD);
    
    uint public lockCount; // Global lock counter, used to derive lockID

    mapping(uint => LockInfo) private locksById; // Permanent mapping of lockID to locked liquidity info
    mapping(address => uint[]) private lockIDsByPairAddress; // Mapping of pair address to lockIDs, modified by withdrawals
    mapping(address => uint[]) private lockIDsByOwner; // Mapping of owner address to lockIDs, modified by withdrawals
    
    IElectroSwapFactory private electroSwapFactory;
    IMigrator private migrator;

    EnumerableSet.AddressSet private noFeeList; // List of addresses that do not pay any fees
    Fees private fees; // Stores the current fee structure

    constructor(IElectroSwapFactory _electroSwapFactory, address _boltAddress) {
        teamWallet = payable(msg.sender);
        electroSwapFactory = _electroSwapFactory;
        boltAddress = _boltAddress;

        fees.etnFlatFee = 1000; // 1000 ETN
        fees.boltFlatFee = 500; // 500 BOLT
        fees.lpPercentFee = 1; // 1%
    }

    function _setFees(uint _etnFlatFee, uint _boltFlatFee, uint _lpPercentFee) external onlyTeam {
        require(_etnFlatFee <= 2000, "Flat fee cannot be greater than 2000 ETN");
        require(_boltFlatFee <= 1000, "Flat fee cannot be greater than 1000 BOLT");
        require(_lpPercentFee <= 2, "LP percentage cannot be greater than 2%");

        fees.etnFlatFee = _etnFlatFee;
        fees.boltFlatFee = _boltFlatFee;
        fees.lpPercentFee = _lpPercentFee;
    }

    function _setTeamWallet(address payable _teamWallet) external onlyTeam {
        require(_teamWallet != address(0), "Team wallet cannot be zero address");
        teamWallet = _teamWallet;
    }

    function _updateFeeWhitelist(address _address, bool _addToWhitelist) external onlyTeam {
        if (_addToWhitelist) {
            noFeeList.add(_address);
        } else {
            noFeeList.remove(_address);
        }
    }

    function _setMigrator(IMigrator _migrator) external onlyTeam {
        migrator = _migrator;
    }

    // Creates a lock for _amountToLock LP tokens of the address provided for _duration (measured in seconds)
    // A flat rate fee is charged to mitigate spam. Pass true for _feeInETN if paying in ETN, or false if paying in BOLT
    // A 1% percent fee (at time of deployment) of deposited liquidity is distributed to the team wallet
    function lock(address _pairAddress, uint _duration, uint _amountToLock, bool _feeInETN) external payable nonReentrant returns (uint){
        require(_duration > 0, "Lock duration must be greater than zero");
        require(_amountToLock > 0, "Amount to lock must be greater than zero");

        // ensure this pair is a univ2 pair by querying the factory
        IElectroSwapPair pair = IElectroSwapPair(address(_pairAddress));
        address factoryPairAddress = electroSwapFactory.getPair(pair.token0(), pair.token1());
        require(factoryPairAddress == _pairAddress, 'Only ElectroSwap LP tokens can be locked');
        
        // requires prior allowance on the LP token contract for this locker contract to transfer LP tokens
        TransferHelper.safeTransferFrom(_pairAddress, address(msg.sender), address(this), _amountToLock); 

        uint256 liquidityFee = 0;

        if (!noFeeList.contains(msg.sender)) {
            if (_feeInETN) { // Flat rate fee to be paid in ETN
                require(msg.value == (fees.etnFlatFee * 1e18), "Flat rate ETN fee not met");
                (bool etnTransferSuccess, ) = teamWallet.call{value: msg.value}("");
                require(etnTransferSuccess, "Failed to transfer ETN");
            } else { // Flat rate fee to be paid in BOLT Token, and then burned
                TransferHelper.safeTransferFrom(address(boltAddress), address(msg.sender), deadAddress, (fees.boltFlatFee * 1e18));
            }
            // percentage of liquidity fee
            liquidityFee = ((_amountToLock * 100) * fees.lpPercentFee) / 10000;
            // round fee up to 1 if truncated
            liquidityFee = liquidityFee == 0 ? 1 : liquidityFee;
            TransferHelper.safeTransfer(_pairAddress, teamWallet, liquidityFee);

        } else if (msg.value > 0){
            // refund ETN if whitelisted
            (bool etnRefundSuccess, ) = payable(msg.sender).call{value: msg.value}("");
            require(etnRefundSuccess, "Failed to refund ETN");
        }

        // If a liquidity fee was charged, remove the fee from the number of tokens that are considered locked.
        uint numTokensLocked = _amountToLock - liquidityFee;

        // Create lock, and increment lock count
        uint lockID = lockCount;
        locksById[lockID] = LockInfo(lockID, _pairAddress, msg.sender, numTokensLocked, numTokensLocked, block.timestamp, _duration);
        lockCount++;

        // Add the lockID to the array associated with the pair and the owner addresses
        lockIDsByPairAddress[_pairAddress].push(lockID);
        lockIDsByOwner[msg.sender].push(lockID);

        emit LiquidityLocked(msg.sender, _pairAddress, numTokensLocked, _duration, lockID);

        return lockID;
    }

    // Withdraws liquidity from a lock to the owner
    // If a the amount to withdraw is less than the amount in the lock, a new lock will be created
    // for the remaining amount using the passed in _remainderDuration (starting at withdrawal time)
    function withdraw(uint _lockID, uint _amountToWithdraw, uint _remainderDuration) external nonReentrant {
        LockInfo storage lockInfo = locksById[_lockID];
        
        require(lockInfo.owner == msg.sender, "Caller is not the owner of the lock");
        require(lockInfo.amount > 0, "No tokens to withdraw");
        require(_amountToWithdraw > 0, "Amount to withdraw must be a positive number");
        require(lockInfo.amount >= _amountToWithdraw, "Cannot withdraw more than is locked");

        // Check if the lock duration has elapsed
        uint elapsedTime = block.timestamp - lockInfo.created;
        require(elapsedTime >= lockInfo.duration, "Lock duration not elapsed");
       
        // Partial withdrawal, create a new lock with the remaining amount for the same duration       
        if (_amountToWithdraw < lockInfo.amount) {
            _splitLockInternal(_lockID, lockInfo.amount - _amountToWithdraw, _remainderDuration);
        } 

        // Remove the lockID from being tracked in lockIDsByPairAddress and lockIDsByOwner mappings. 
        _removeLockReferenceFromPair(lockInfo);
        _removeLockReferenceFromOwner(lockInfo);

        // Remove the amount being withdrawn from the lock
        lockInfo.amount -= _amountToWithdraw;

        // Transfer the requested tokens back to the user
        TransferHelper.safeTransfer(lockInfo.pair, msg.sender, _amountToWithdraw);
        emit LiquidityWithdrawn(msg.sender, lockInfo.pair, _amountToWithdraw, _lockID);
    }

    // Reentrancy protection wrapper that splits locks
    function splitLock(uint _lockID, uint _newLockAmount, uint _newLockDuration) public nonReentrant {
        _splitLockInternal(_lockID, _newLockAmount, _newLockDuration);
    }

    // Transfer ownership to a new owner. Only the owner of the lock can call this function.
    function transferLock(uint _lockID, address _newOwner) external nonReentrant {

        require(_newOwner != address(0), "New owner cannot be zero address");
        
        LockInfo storage lockInfo = locksById[_lockID];
        require(lockInfo.owner == msg.sender, "Caller is not the current owner of the lock");
        
        // Remove lock reference from current owner
        _removeLockReferenceFromOwner(lockInfo);

        // Set new owner and add lock reference for new owner
        lockInfo.owner = _newOwner;
        lockIDsByOwner[_newOwner].push(_lockID);
        
        emit LockTransferred(_lockID, msg.sender, _newOwner);
    }

    // Increases the amount of LP tokens locked, and/or extends the duration beyond the existing duration
    // NOTE: The create timestamp is not modified, so ensure that the desired end time is based on create time and the current duration
    function increaseLock(uint _lockID, uint _additionalTokens, uint _additionalTime) external nonReentrant {
        LockInfo storage lockInfo = locksById[_lockID];
        require(lockInfo.owner == msg.sender, "Caller is not the owner of the lock");
        require(_additionalTokens > 0 || _additionalTime > 0, "Must add LP tokens, or time (or both)");
        
        // Increase the duration of the lock
        uint existingDuration = lockInfo.duration;
        if (_additionalTime > 0) {
            require(lockInfo.created + lockInfo.duration + _additionalTime > block.timestamp, "Lock maturation would be in the past");
            lockInfo.duration += _additionalTime;
        }

        // Transfer the additional tokens, and increase amount of the lock
        uint existingAmount = lockInfo.amount;
        if (_additionalTokens > 0) {
            
            // requires prior allowance on the LP token contract for this locker contract to transfer LP tokens
            TransferHelper.safeTransferFrom(lockInfo.pair, address(msg.sender), address(this), _additionalTokens); 
            
            uint256 liquidityFee = 0;
            if (!noFeeList.contains(msg.sender)) {
                // percentage of liquidity fee transferred to the team wallet
                liquidityFee = ((_additionalTokens * 100) * fees.lpPercentFee) / 10000;
                // round fee up to 1 if truncated
                liquidityFee = liquidityFee == 0 ? 1 : liquidityFee;
                TransferHelper.safeTransfer(lockInfo.pair, teamWallet, liquidityFee);
            }

            // If a liquidity fee was charged, remove the fee from the number of tokens that are considered locked.
            uint additionalAmountToLock = _additionalTokens - liquidityFee;

            lockInfo.amount += additionalAmountToLock;
        }

        emit LockIncreased(_lockID, existingAmount, existingDuration, lockInfo.amount, lockInfo.duration);
    }

    // To be used in future if Uniswap V3 type liquidity support is added
    function migrateLock(uint _lockID) external nonReentrant {
        require(address(migrator) != address(0), "Migrator not set");

        LockInfo storage lockInfo = locksById[_lockID];
        require(lockInfo.owner == msg.sender, "Caller is not the owner of the lock");
        require(lockInfo.amount > 0, "No tokens to migrate");

        // Mark the lock as empty before external call
        uint256 amountToMigrate = lockInfo.amount;
        lockInfo.amount = 0;

        // Transfer the LP tokens to the migrator contract
        TransferHelper.safeTransfer(lockInfo.pair, address(migrator), amountToMigrate);

        // Attempt to migrate the tokens
        require(migrator.migrate(lockInfo.pair, lockInfo.owner, amountToMigrate, lockInfo.created, lockInfo.duration), "Migration failed");

        emit LockMigrated(_lockID);
    }

    function getLockById(uint _lockID) external view returns (LockInfo memory){
        return locksById[_lockID];
    }

    function getLockIDsByPairAddress(address _pairAddress) external view returns (uint[] memory){
        return lockIDsByPairAddress[_pairAddress];
    }

    function getLockIDsByOwner(address _owner) external view returns (uint[] memory){
        return lockIDsByOwner[_owner];
    }

    function getBlockTime() external view returns (uint){
        return block.timestamp;
    }

    // This returns fees with decimals considered to be easily human readable. 
    // The flat rate fee values get multiplied by 1e18 for the actual fee amount
    function getFees(bool _noop) external view returns (Fees memory){
        return _noop ? fees : fees;
    }
    
    // Used to split locks, called from external facing functions
    function _splitLockInternal(uint _lockID, uint _newLockAmount, uint _newLockDuration) internal {
        LockInfo storage originalLock = locksById[_lockID];
        
        require(originalLock.owner == msg.sender, "Caller is not the owner of the lock");
        require(_newLockAmount > 0, "New lock amount must be > 0");
        require(_newLockDuration > 0, "New lock duration must be > 0");
        require(originalLock.amount >= _newLockAmount, "New amount must be less than to the original amount");

        // Calculate original lock's maturation time
        uint originalLockMaturation = originalLock.created + originalLock.duration;
        // Ensure the new lock's maturation time is after the original lock's maturation time
        require(block.timestamp + _newLockDuration > originalLockMaturation, "New lock's maturation must be after the original lock's maturation");

        // Reduce the amount of the original lock
        originalLock.amount -= _newLockAmount;

        // Create a new lock with the new amount and duration
        uint newLockID = lockCount;
        locksById[newLockID] = LockInfo(newLockID, originalLock.pair, originalLock.owner, _newLockAmount, _newLockAmount, block.timestamp, _newLockDuration);

        // Increment the global lock counter
        lockCount++;

        // Add the new lockID to the arrays associated with the pair address and owner address
        lockIDsByPairAddress[originalLock.pair].push(newLockID);
        lockIDsByOwner[originalLock.owner].push(newLockID);

        emit LockSplit(originalLock.lockID, newLockID);
        emit LiquidityLocked(originalLock.owner, originalLock.pair, _newLockAmount, _newLockDuration, newLockID);
    }

    // Remove the lockID from lockIDsByPairAddress mapping
    function _removeLockReferenceFromPair(LockInfo memory _lockInfo) internal {
        uint[] storage pairLockIDs = lockIDsByPairAddress[_lockInfo.pair];
        for (uint i = 0; i < pairLockIDs.length; i++) {
            if (pairLockIDs[i] == _lockInfo.lockID) {
                pairLockIDs[i] = pairLockIDs[pairLockIDs.length - 1];
                pairLockIDs.pop();
                break;
            }
        }
    }

    // Remove the lockID from lockIDsByOwner mapping
    function _removeLockReferenceFromOwner(LockInfo memory _lockInfo) internal {
        uint[] storage ownerLockIDs = lockIDsByOwner[_lockInfo.owner];
        for (uint i = 0; i < ownerLockIDs.length; i++) {
            if (ownerLockIDs[i] == _lockInfo.lockID) {
                ownerLockIDs[i] = ownerLockIDs[ownerLockIDs.length - 1];
                ownerLockIDs.pop();
                break;
            }
        }
    }
}
        

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/structs/EnumerableSet.sol)
// This file was procedurally generated from scripts/generate/templates/EnumerableSet.js.

pragma solidity ^0.8.20;

/**
 * @dev Library for managing
 * https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive
 * types.
 *
 * Sets have the following properties:
 *
 * - Elements are added, removed, and checked for existence in constant time
 * (O(1)).
 * - Elements are enumerated in O(n). No guarantees are made on the ordering.
 *
 * ```solidity
 * contract Example {
 *     // Add the library methods
 *     using EnumerableSet for EnumerableSet.AddressSet;
 *
 *     // Declare a set state variable
 *     EnumerableSet.AddressSet private mySet;
 * }
 * ```
 *
 * As of v3.3.0, sets of type `bytes32` (`Bytes32Set`), `address` (`AddressSet`)
 * and `uint256` (`UintSet`) are supported.
 *
 * [WARNING]
 * ====
 * Trying to delete such a structure from storage will likely result in data corruption, rendering the structure
 * unusable.
 * See https://github.com/ethereum/solidity/pull/11843[ethereum/solidity#11843] for more info.
 *
 * In order to clean an EnumerableSet, you can either remove all elements one by one or create a fresh instance using an
 * array of EnumerableSet.
 * ====
 */
library EnumerableSet {
    // To implement this library for multiple types with as little code
    // repetition as possible, we write it in terms of a generic Set type with
    // bytes32 values.
    // The Set implementation uses private functions, and user-facing
    // implementations (such as AddressSet) are just wrappers around the
    // underlying Set.
    // This means that we can only create new EnumerableSets for types that fit
    // in bytes32.

    struct Set {
        // Storage of set values
        bytes32[] _values;
        // Position is the index of the value in the `values` array plus 1.
        // Position 0 is used to mean a value is not in the set.
        mapping(bytes32 value => uint256) _positions;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function _add(Set storage set, bytes32 value) private returns (bool) {
        if (!_contains(set, value)) {
            set._values.push(value);
            // The value is stored at length-1, but we add 1 to all indexes
            // and use 0 as a sentinel value
            set._positions[value] = set._values.length;
            return true;
        } else {
            return false;
        }
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function _remove(Set storage set, bytes32 value) private returns (bool) {
        // We cache the value's position to prevent multiple reads from the same storage slot
        uint256 position = set._positions[value];

        if (position != 0) {
            // Equivalent to contains(set, value)
            // To delete an element from the _values array in O(1), we swap the element to delete with the last one in
            // the array, and then remove the last element (sometimes called as 'swap and pop').
            // This modifies the order of the array, as noted in {at}.

            uint256 valueIndex = position - 1;
            uint256 lastIndex = set._values.length - 1;

            if (valueIndex != lastIndex) {
                bytes32 lastValue = set._values[lastIndex];

                // Move the lastValue to the index where the value to delete is
                set._values[valueIndex] = lastValue;
                // Update the tracked position of the lastValue (that was just moved)
                set._positions[lastValue] = position;
            }

            // Delete the slot where the moved value was stored
            set._values.pop();

            // Delete the tracked position for the deleted slot
            delete set._positions[value];

            return true;
        } else {
            return false;
        }
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function _contains(Set storage set, bytes32 value) private view returns (bool) {
        return set._positions[value] != 0;
    }

    /**
     * @dev Returns the number of values on the set. O(1).
     */
    function _length(Set storage set) private view returns (uint256) {
        return set._values.length;
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function _at(Set storage set, uint256 index) private view returns (bytes32) {
        return set._values[index];
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function _values(Set storage set) private view returns (bytes32[] memory) {
        return set._values;
    }

    // Bytes32Set

    struct Bytes32Set {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(Bytes32Set storage set, bytes32 value) internal returns (bool) {
        return _add(set._inner, value);
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) {
        return _remove(set._inner, value);
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) {
        return _contains(set._inner, value);
    }

    /**
     * @dev Returns the number of values in the set. O(1).
     */
    function length(Bytes32Set storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) {
        return _at(set._inner, index);
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function values(Bytes32Set storage set) internal view returns (bytes32[] memory) {
        bytes32[] memory store = _values(set._inner);
        bytes32[] memory result;

        /// @solidity memory-safe-assembly
        assembly {
            result := store
        }

        return result;
    }

    // AddressSet

    struct AddressSet {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(AddressSet storage set, address value) internal returns (bool) {
        return _add(set._inner, bytes32(uint256(uint160(value))));
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(AddressSet storage set, address value) internal returns (bool) {
        return _remove(set._inner, bytes32(uint256(uint160(value))));
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(AddressSet storage set, address value) internal view returns (bool) {
        return _contains(set._inner, bytes32(uint256(uint160(value))));
    }

    /**
     * @dev Returns the number of values in the set. O(1).
     */
    function length(AddressSet storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(AddressSet storage set, uint256 index) internal view returns (address) {
        return address(uint160(uint256(_at(set._inner, index))));
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function values(AddressSet storage set) internal view returns (address[] memory) {
        bytes32[] memory store = _values(set._inner);
        address[] memory result;

        /// @solidity memory-safe-assembly
        assembly {
            result := store
        }

        return result;
    }

    // UintSet

    struct UintSet {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(UintSet storage set, uint256 value) internal returns (bool) {
        return _add(set._inner, bytes32(value));
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(UintSet storage set, uint256 value) internal returns (bool) {
        return _remove(set._inner, bytes32(value));
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(UintSet storage set, uint256 value) internal view returns (bool) {
        return _contains(set._inner, bytes32(value));
    }

    /**
     * @dev Returns the number of values in the set. O(1).
     */
    function length(UintSet storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(UintSet storage set, uint256 index) internal view returns (uint256) {
        return uint256(_at(set._inner, index));
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function values(UintSet storage set) internal view returns (uint256[] memory) {
        bytes32[] memory store = _values(set._inner);
        uint256[] memory result;

        /// @solidity memory-safe-assembly
        assembly {
            result := store
        }

        return result;
    }
}
          

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

pragma solidity ^0.8.20;

/**
 * @dev Contract module that helps prevent reentrant calls to a function.
 *
 * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier
 * available, which can be applied to functions to make sure there are no nested
 * (reentrant) calls to them.
 *
 * Note that because there is a single `nonReentrant` guard, functions marked as
 * `nonReentrant` may not call one another. This can be worked around by making
 * those functions `private`, and then adding `external` `nonReentrant` entry
 * points to them.
 *
 * TIP: If you would like to learn more about reentrancy and alternative ways
 * to protect against it, check out our blog post
 * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
 */
abstract contract ReentrancyGuard {
    // Booleans are more expensive than uint256 or any type that takes up a full
    // word because each write operation emits an extra SLOAD to first read the
    // slot's contents, replace the bits taken up by the boolean, and then write
    // back. This is the compiler's defense against contract upgrades and
    // pointer aliasing, and it cannot be disabled.

    // The values being non-zero value makes deployment a bit more expensive,
    // but in exchange the refund on every call to nonReentrant will be lower in
    // amount. Since refunds are capped to a percentage of the total
    // transaction's gas, it is best to keep them low in cases like this one, to
    // increase the likelihood of the full refund coming into effect.
    uint256 private constant NOT_ENTERED = 1;
    uint256 private constant ENTERED = 2;

    uint256 private _status;

    /**
     * @dev Unauthorized reentrant call.
     */
    error ReentrancyGuardReentrantCall();

    constructor() {
        _status = NOT_ENTERED;
    }

    /**
     * @dev Prevents a contract from calling itself, directly or indirectly.
     * Calling a `nonReentrant` function from another `nonReentrant`
     * function is not supported. It is possible to prevent this from happening
     * by making the `nonReentrant` function external, and making it call a
     * `private` function that does the actual work.
     */
    modifier nonReentrant() {
        _nonReentrantBefore();
        _;
        _nonReentrantAfter();
    }

    function _nonReentrantBefore() private {
        // On the first call to nonReentrant, _status will be NOT_ENTERED
        if (_status == ENTERED) {
            revert ReentrancyGuardReentrantCall();
        }

        // Any calls to nonReentrant after this point will fail
        _status = ENTERED;
    }

    function _nonReentrantAfter() private {
        // By storing the original value once again, a refund is triggered (see
        // https://eips.ethereum.org/EIPS/eip-2200)
        _status = NOT_ENTERED;
    }

    /**
     * @dev Returns true if the reentrancy guard is currently set to "entered", which indicates there is a
     * `nonReentrant` function in the call stack.
     */
    function _reentrancyGuardEntered() internal view returns (bool) {
        return _status == ENTERED;
    }
}
          

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

// helper methods for interacting with ERC20 tokens that do not consistently return true/false
library TransferHelper {
    function safeApprove(address token, address to, uint value) internal {
        (bool success, bytes memory data) = token.call(abi.encodeWithSelector(0x095ea7b3, to, value));
        require(success && (data.length == 0 || abi.decode(data, (bool))), 'TransferHelper: APPROVE_FAILED');
    }

    function safeTransfer(address token, address to, uint value) internal {
        (bool success, bytes memory data) = token.call(abi.encodeWithSelector(0xa9059cbb, to, value));
        require(success && (data.length == 0 || abi.decode(data, (bool))), 'TransferHelper: TRANSFER_FAILED');
    }

    function safeTransferFrom(address token, address from, address to, uint value) internal {
        (bool success, bytes memory data) = token.call(abi.encodeWithSelector(0x23b872dd, from, to, value));
        require(success && (data.length == 0 || abi.decode(data, (bool))), 'TransferHelper: TRANSFER_FROM_FAILED');
    }

}