// SPDX-License-Identifier: Apache-2.0
pragma solidity ^0.8.18;

import "@openzeppelin/contracts/token/ERC20/ERC20.sol";

contract SyloToken is ERC20 {
    constructor() ERC20("Sylo", "SYLO") {
        _mint(msg.sender, 10_000_000_000 ether);
    }
}

// SPDX-License-Identifier: Apache-2.0
pragma solidity ^0.8.18;

import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/utils/introspection/ERC165.sol";
import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
import "@openzeppelin/contracts-upgradeable/access/Ownable2StepUpgradeable.sol";

import "./libraries/SyloUtils.sol";
import "./interfaces/IRegistries.sol";

/**
 * @notice This contract manages Registries for Nodes. A Registry is a
 * set of parameters configured by the Node itself. A Node is required
 * to have a valid Registry to be able to participate in the network.
 */
contract Registries is IRegistries, Initializable, Ownable2StepUpgradeable, IERC165 {
    using ECDSA for bytes32;

    /**
     * @notice ERC721 contract for bridged Seekers. Used for verifying ownership
     * of a seeker.
     */
    IERC721 public _rootSeekers;

    /**
     * @notice Tracks each Node's registry.
     */
    mapping(address => IRegistries.Registry) public registries;

    /**
     * @notice Tracks the node address that each seeker id is registered with
     */
    mapping(uint256 => address) public seekerRegistration;

    /**
     * @notice Tracks the address of every registered node.
     */
    address[] public nodes;

    /**
     * @notice Tracks nonces used when registering the seeker account
     * to prevent signature re-use.
     */
    mapping(bytes32 => address) private signatureNonces;

    /**
     * @notice Payout percentage refers to the portion of a tickets reward
     * that will be allocated to the Node's stakers. This is global, and is
     * currently set for all Nodes.
     */
    uint32 public defaultPayoutPercentage;

    event DefaultPayoutPercentageUpdated(uint32 defaultPayoutPercentage);

    error NonceCannotBeReused();
    error EndMustBeGreaterThanStart();
    error PercentageCannotExceed100000();
    error PublicEndpointCannotBeEmpty();
    error SeekerAccountMustOwnSeekerId();
    error SeekerAccountMustBeMsgSender();
    error ProofNotSignedBySeekerAccount();
    error RootSeekersCannotBeZeroAddress();
    error SeekerAccountCannotBeZeroAddress();
    error EndCannotExceedNumberOfNodes(uint256 nodeLength);

    function initialize(
        IERC721 rootSeekers,
        uint32 _defaultPayoutPercentage
    ) external initializer {
        if (address(rootSeekers) == address(0)) {
            revert RootSeekersCannotBeZeroAddress();
        }
        if (_defaultPayoutPercentage > 100000) {
            revert PercentageCannotExceed100000();
        }

        Ownable2StepUpgradeable.__Ownable2Step_init();

        _rootSeekers = rootSeekers;
        defaultPayoutPercentage = _defaultPayoutPercentage;
    }

    /**
     * @notice Returns true if the contract implements the interface defined by
     * `interfaceId` from ERC165.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
        return interfaceId == type(IRegistries).interfaceId;
    }

    /**
     * @notice Set the global default payout percentage value. Only callable
     * by the owner.
     * @param _defaultPayoutPercentage The payout percentage as a value where the
     * denominator is 100000.
     */
    function setDefaultPayoutPercentage(uint32 _defaultPayoutPercentage) external onlyOwner {
        if (_defaultPayoutPercentage > 100000) {
            revert PercentageCannotExceed100000();
        }

        defaultPayoutPercentage = _defaultPayoutPercentage;
        emit DefaultPayoutPercentageUpdated(_defaultPayoutPercentage);
    }

    /**
     * @notice Call this as a Node to set or update your Registry entry.
     * @param publicEndpoint The public endpoint of your Node. Essential for
     * clients to be able to retrieve additional information, such as
     * an address to establish a p2p connection.
     */
    function register(string calldata publicEndpoint) external {
        if (bytes(publicEndpoint).length == 0) {
            revert PublicEndpointCannotBeEmpty();
        }

        // This is the nodes first registration
        if (bytes(registries[msg.sender].publicEndpoint).length == 0) {
            nodes.push(msg.sender);
        }

        registries[msg.sender].publicEndpoint = publicEndpoint;
    }

    function setSeekerAccount(
        address seekerAccount,
        uint256 seekerId,
        bytes32 nonce,
        bytes calldata signature
    ) external {
        if (seekerAccount == address(0)) {
            revert SeekerAccountCannotBeZeroAddress();
        }
        if (signatureNonces[nonce] != address(0)) {
            revert NonceCannotBeReused();
        }

        bytes memory proofMessage = getProofMessage(seekerId, msg.sender, nonce);
        bytes32 ethProof = ECDSA.toEthSignedMessageHash(proofMessage);

        if (ECDSA.recover(ethProof, signature) != seekerAccount) {
            revert ProofNotSignedBySeekerAccount();
        }

        // Now verify the seeker account actually owns the seeker
        address owner = _rootSeekers.ownerOf(seekerId);

        if (seekerAccount != owner) {
            revert SeekerAccountMustOwnSeekerId();
        }

        delete registries[seekerRegistration[seekerId]].seekerId;
        delete registries[seekerRegistration[seekerId]].seekerAccount;

        registries[msg.sender].seekerAccount = seekerAccount;
        registries[msg.sender].seekerId = seekerId;

        seekerRegistration[seekerId] = msg.sender;

        signatureNonces[nonce] = seekerAccount;
    }

    function revokeSeekerAccount(address node) external {
        Registry storage registry = registries[node];

        if (registry.seekerAccount != msg.sender) {
            revert SeekerAccountMustBeMsgSender();
        }

        delete registry.seekerAccount;
        delete seekerRegistration[registry.seekerId];
        delete registry.seekerId;
    }

    /**
     * @notice Retrieve the registry associated with a Node.
     * @param account The address of the Node.
     * @return The Node's Registry.
     */
    function getRegistry(address account) external view returns (Registry memory) {
        return registries[account];
    }

    /**
     * @notice Retrieve all registered nodes.
     * @return An array of node addresses.
     */
    function getNodes() external view returns (address[] memory) {
        return nodes;
    }

    /**
     * @notice Retrieves a list of registries. Takes in a
     * a start and end indices to allow pagination.
     * @param start The start index which is inclusive.
     * @param end The end index which is exclusive.
     * @return An array of Registries.
     */
    function getRegistries(
        uint256 start,
        uint256 end
    ) external view returns (address[] memory, Registry[] memory) {
        uint256 nodesLength = nodes.length;

        if (end <= start) {
            revert EndMustBeGreaterThanStart();
        }
        if (end > nodesLength) {
            revert EndCannotExceedNumberOfNodes(nodesLength);
        }

        address[] memory _nodes = new address[](end - start);
        Registry[] memory _registries = new Registry[](_nodes.length);

        for (uint256 i = start; i < end; ++i) {
            _nodes[i - start] = nodes[i];
            _registries[i - start] = registries[nodes[i]];
        }

        return (_nodes, _registries);
    }

    /**
     * @notice Returns the total number of registered nodes.
     * @return The number of registered nodes.
     */
    function getTotalNodes() external view returns (uint256) {
        return nodes.length;
    }

    /**
     * @notice Helper function for deriving the proof message used to
     * validate seeker ownership.
     * @param seekerId The tokenId of the seeker used for operation.
     * @param node The address of the node which that will be operated
     * by the specified seeker.
     * @param nonce The nonce used for this message.
     */
    function getProofMessage(
        uint256 seekerId,
        address node,
        bytes32 nonce
    ) public pure returns (bytes memory) {
        return
            abi.encodePacked(
                unicode"🤖 Hi frend! 🤖\n\n📜 Signing this message proves that you're the owner of this Seeker NFT and allows your Seeker to be used to operate your Seeker's Node. It's a simple but important step to ensure smooth operation.\n\nThis request will not trigger a blockchain transaction or cost any gas fees.\n\n🔥 Your node's address: ",
                Strings.toHexString(uint256(uint160(node)), 20),
                unicode"\n\n🆔 Your seeker id: ",
                Strings.toString(seekerId),
                unicode"\n\n📦 A unique random value which secures this message: ",
                Strings.toHexString(uint256(nonce), 32)
            );
    }
}

// SPDX-License-Identifier: Apache-2.0
pragma solidity ^0.8.18;

import "@openzeppelin/contracts-upgradeable/access/Ownable2StepUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/introspection/ERC165.sol";

import "./interfaces/ISeekerPowerOracle.sol";

/**
 * @notice Acts as a source of information for Seeker Powers. Allows setting
 * a Seeker's power level via a restricted oracle account call. Seeker Power can also
 * be set by any account if the correct Oracle signature proof is provided.
 */
contract SeekerPowerOracle is ISeekerPowerOracle, Initializable, Ownable2StepUpgradeable, ERC165 {
    /**
     * @notice The oracle account. This contract accepts any attestations of
     * Seeker power that have been signed by this account.
     */
    address public oracle;

    /**
     * @notice Tracks nonce used when register the Seeker power to
     * prevent signature re-use.
     */
    mapping(bytes32 => address) private proofNonces;

    /**
     * @notice Tracks the set of Seeker Power levels.
     */
    mapping(uint256 => uint256) public seekerPowers;

    event SeekerPowerUpdated(uint256 indexed seekerId, uint256 indexed power);

    error UnauthorizedRegisterSeekerPowerCall();
    error NonceCannotBeReused();
    error PowerCannotBeZero();
    error OracleCannotBeZeroAddress();

    function initialize(address _oracle) external initializer {
        Ownable2StepUpgradeable.__Ownable2Step_init();

        if (_oracle == address(0)) {
            revert OracleCannotBeZeroAddress();
        }

        oracle = _oracle;
    }

    /**
     * @notice Returns true if the contract implements the interface defined by
     * `interfaceId` from ERC165.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
        return interfaceId == type(ISeekerPowerOracle).interfaceId;
    }

    /**
     * @notice Sets the oracle account.
     * @param _oracle The oracle account.
     */
    function setOracle(address _oracle) external onlyOwner {
        oracle = _oracle;
    }

    /**
     * @notice Registers a Seeker's power level. Only callable by the
     * owner or the oracle account.
     * @param seekerId The id of the Seeker.
     * @param power The power level of the Seeker.
     */
    function registerSeekerPowerRestricted(uint256 seekerId, uint256 power) external {
        if (msg.sender != oracle) {
            revert UnauthorizedRegisterSeekerPowerCall();
        }

        if (power == 0) {
            revert PowerCannotBeZero();
        }

        seekerPowers[seekerId] = power;
        emit SeekerPowerUpdated(seekerId, power);
    }

    /**
     * @notice Registers a Seeker's power level. Callable by any account
     * but requires a proof signed by the oracle.
     * @param seekerId The id of the Seeker.
     * @param power The power level of the Seeker.
     */
    function registerSeekerPower(
        uint256 seekerId,
        uint256 power,
        bytes32 nonce,
        bytes calldata proof
    ) external {
        if (proofNonces[nonce] != address(0)) {
            revert NonceCannotBeReused();
        }

        if (power == 0) {
            revert PowerCannotBeZero();
        }

        bytes memory proofMessage = getProofMessage(seekerId, power, nonce);
        bytes32 ecdsaHash = ECDSA.toEthSignedMessageHash(proofMessage);

        if (ECDSA.recover(ecdsaHash, proof) != oracle) {
            revert UnauthorizedRegisterSeekerPowerCall();
        }

        seekerPowers[seekerId] = power;
        proofNonces[nonce] = oracle;

        emit SeekerPowerUpdated(seekerId, power);
    }

    /**
     * @notice Retrieves a Seeker's stored power level.
     * @param seekerId The id of the Seeker.
     */
    function getSeekerPower(uint256 seekerId) external view returns (uint256) {
        return seekerPowers[seekerId];
    }

    /**
     * @notice Constructs a proof message for the oracle to sign.
     * @param seekerId The id of the Seeker.
     * @param power The power level of the Seeker.
     */
    function getProofMessage(
        uint256 seekerId,
        uint256 power,
        bytes32 nonce
    ) public pure returns (bytes memory) {
        return
            abi.encodePacked(
                Strings.toString(seekerId),
                ":",
                Strings.toString(power),
                ":",
                Strings.toHexString(uint256(nonce), 32)
            );
    }
}

// SPDX-License-Identifier: Apache-2.0
pragma solidity ^0.8.18;

import "@openzeppelin/contracts/utils/math/Math.sol";

import "./StakingManager.sol";
import "../libraries/SyloUtils.sol";
import "../libraries/Manageable.sol";
import "../interfaces/staking/IDirectory.sol";
import "../payments/ticketing/RewardsManager.sol";

/**
 * @notice The Directory contract constructs and manages a structure holding the current stakes,
 * which is queried against using the scan function. The scan function allows submitting
 * random points which will return a staked node's address in proportion to the stake it has.
 */
contract Directory is IDirectory, Initializable, Manageable, IERC165 {
    /** Sylo Staking Manager contract */
    StakingManager public _stakingManager;

    /** Sylo Rewards Manager contract */
    RewardsManager public _rewardsManager;

    /**
     * @notice The epoch ID of the current directory.
     */
    uint256 public currentDirectory;

    /**
     * @notice Tracks every directory, which will be indexed by an epoch ID
     */
    mapping(uint256 => EpochDirectory) public directories;

    event CurrentDirectoryUpdated(uint256 indexed currentDirectory);

    error NoStakeToJoinEpoch();
    error StakeeAlreadyJoinedEpoch();
    error StakeeCannotBeZeroAddress();
    error NoJoiningStakeToJoinEpoch();

    function initialize(
        StakingManager stakingManager,
        RewardsManager rewardsManager
    ) external initializer {
        SyloUtils.validateContractInterface(
            "StakingManager",
            address(stakingManager),
            type(IStakingManager).interfaceId
        );

        SyloUtils.validateContractInterface(
            "RewardsManager",
            address(rewardsManager),
            type(IRewardsManager).interfaceId
        );

        Ownable2StepUpgradeable.__Ownable2Step_init();

        _stakingManager = stakingManager;
        _rewardsManager = rewardsManager;
    }

    /**
     * @notice Returns true if the contract implements the interface defined by
     * `interfaceId` from ERC165.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
        return interfaceId == type(IDirectory).interfaceId;
    }

    /**
     * @notice This function should be called when a new epoch is initialized.
     * This will set the current directory to the specified epoch. This is only
     * callable by the owner of this contract, which should be the EpochsManager
     * contract.
     * @dev After deployment, the EpochsManager should immediately be set as
     * the owner.
     * @param epochId The ID of the specified epoch.
     */
    function setCurrentDirectory(uint256 epochId) external onlyManager {
        currentDirectory = epochId;
        emit CurrentDirectoryUpdated(epochId);
    }

    /**
     * @notice This function is called by the epochs manager as a prerequisite to when the node joins the next epoch.
     * @param stakee The address of the node.
     * @param seekerId The seekerId of the Seeker that the node is
     * registered with when joining the epoch. It is used to determine the nodes
     * staking capacity based on its seeker power.
     *
     * @dev This will construct the directory as nodes join. The directory is constructed
     * by creating a boundary value which is a sum of the current directory's total stake, and
     * the current stakee's total stake, and pushing the new boundary into the entries array.
     * The previous boundary and the current boundary essentially create a range, where if a
     * random point were to fall within that range, it would belong to the respective stakee.
     * The boundary value grows in size as each stakee joins, thus the directory array
     * always remains sorted. This allows us to perform a binary search on the directory.
     *
     * Example
     *
     * Stakes: [ Alice/20, Bob/10, Carl/40, Dave/25 ]
     * TotalStake: 95
     *
     * EpochDirectory:
     *
     *  |-----------|------|----------------|--------|
     *     Alice/20  Bob/30     Carl/70      Dave/95
     *
     * The amount of stake that a node will join a directory with is dependent on its
     * different capacity values. There are two distinct capacity values, one
     * calculated from the seeker power, and another from the minimum stake
     * proportion. The final staking amount will not exceed either capacities,
     * and in the case that the current total stake exceeds both, then the final
     * will be the minimum of the two values.
     */
    function joinNextDirectory(address stakee, uint256 seekerId) external onlyManager {
        if (stakee == address(0)) {
            revert StakeeCannotBeZeroAddress();
        }

        uint256 nextEpochId = currentDirectory + 1;

        uint256 totalStake = _stakingManager.getStakeeTotalManagedStake(stakee);
        if (totalStake == 0) {
            revert NoStakeToJoinEpoch();
        }

        // staking capacity based on seeker power
        uint256 seekerStakingCapacity = _stakingManager.calculateCapacityFromSeekerPower(seekerId);

        // staking capacity based on the min staking proportion constant
        uint256 minProportionStakingCapacity = _stakingManager.calculateCapacityFromMinStakingProportion(stakee);

        uint256 joiningStake;
        if (totalStake > seekerStakingCapacity && totalStake > minProportionStakingCapacity) {
            joiningStake = Math.min(seekerStakingCapacity, minProportionStakingCapacity);
        } else if (totalStake > seekerStakingCapacity) {
            joiningStake = seekerStakingCapacity;
        } else if (totalStake > minProportionStakingCapacity) {
            joiningStake = minProportionStakingCapacity;
        } else { // uncapped
            joiningStake = totalStake;
        }

        if (joiningStake == 0) {
            revert NoJoiningStakeToJoinEpoch();
        }

        if (directories[nextEpochId].stakes[stakee] > 0) {
            revert StakeeAlreadyJoinedEpoch();
        }

        uint256 nextBoundary = directories[nextEpochId].totalStake + joiningStake;

        directories[nextEpochId].entries.push(DirectoryEntry(stakee, nextBoundary));
        directories[nextEpochId].stakes[stakee] = joiningStake;
        directories[nextEpochId].totalStake = nextBoundary;
    }

    /**
     * @notice Call this to perform a stake-weighted scan to find the Node assigned
     * to the given point of the current directory.
     * @param point The point, which will usually be a hash of a public key.
     */
    function scan(uint128 point) external view returns (address stakee) {
        return _scan(point, currentDirectory);
    }

    /**
     * @notice Call this to perform a stake-weighted scan to find the Node assigned
     * to the given point of the requested directory.
     * @param point The point, which will usually be a hash of a public key.
     * @param epochId The epoch id associated with the directory to scan.
     */
    function scanWithEpochId(
        uint128 point,
        uint256 epochId
    ) external view returns (address stakee) {
        return _scan(point, epochId);
    }

    /**
     * @notice Call this to perform a stake-weighted scan to find the Node assigned
     * to the given point of the requested directory (internal).
     * @dev The current implementation will perform a binary search through
     * the directory. This can allow gas costs to be low if this needs to be
     * used in a transaction.
     * @param point The point, which will usually be a hash of a public key.
     * @param epochId The epoch id associated with the directory to scan.
     */
    function _scan(uint128 point, uint256 epochId) internal view returns (address stakee) {
        uint256 entryLength = directories[epochId].entries.length;

        if (entryLength == 0) {
            return address(0);
        }

        // Staking all the Sylo would only be 94 bits, so multiplying this with
        // a uint128 cannot overflow a uint256.
        uint256 expectedVal = (directories[epochId].totalStake * uint256(point)) >> 128;

        uint256 left;
        uint256 right = entryLength - 1;

        // perform a binary search through the directory
        uint256 lower;
        uint256 upper;
        uint256 index;

        while (left <= right) {
            index = (left + right) >> 1;

            lower = index == 0 ? 0 : directories[epochId].entries[index - 1].boundary;
            upper = directories[epochId].entries[index].boundary;

            if (expectedVal >= lower && expectedVal < upper) {
                return directories[epochId].entries[index].stakee;
            } else if (expectedVal < lower) {
                right = index - 1;
            } else {
                // expectedVal >= upper
                left = index + 1;
            }
        }
    }

    /**
     * @notice Retrieve the total stake a Node has for the directory in the
     * specified epoch.
     * @param epochId The ID of the epoch.
     * @param stakee The address of the Node.
     * @return The amount of stake the Node has for the given directory in SOLO.
     */
    function getTotalStakeForStakee(
        uint256 epochId,
        address stakee
    ) external view returns (uint256) {
        return directories[epochId].stakes[stakee];
    }

    /**
     * @notice Retrieve the total stake for a directory in the specified epoch, which
     * will be the sum of the stakes for all Nodes participating in that epoch.
     * @param epochId The ID of the epoch.
     * @return The total amount of stake in SOLO.
     */
    function getTotalStake(uint256 epochId) external view returns (uint256) {
        return directories[epochId].totalStake;
    }

    /**
     * @notice Retrieve all entries for a directory in a specified epoch.
     * @return An array of all the directory entries.
     */
    function getEntries(
        uint256 epochId
    ) external view returns (address[] memory, uint256[] memory) {
        uint256 entryLength = directories[epochId].entries.length;

        address[] memory stakees = new address[](entryLength);
        uint256[] memory boundaries = new uint256[](entryLength);

        DirectoryEntry memory entry;
        DirectoryEntry[] memory entries = directories[epochId].entries;

        for (uint256 i; i < entryLength; ++i) {
            entry = entries[i];
            stakees[i] = entry.stakee;
            boundaries[i] = entry.boundary;
        }
        return (stakees, boundaries);
    }
}

// SPDX-License-Identifier: Apache-2.0
pragma solidity ^0.8.18;

import "@openzeppelin/contracts/utils/math/SafeCast.sol";
import "@openzeppelin/contracts/utils/introspection/ERC165.sol";

error ContractNameCannotBeEmpty();
error InterfaceIdCannotBeZeroBytes();
error TargetContractCannotBeZeroAddress(string name);
error TargetNotSupportInterface(string name, bytes4 interfaceId);

library SyloUtils {
    /**
     * @dev The maximum possible SYLO that exists in the network.
     */
    uint256 public constant MAX_SYLO = 10_000_000_000 ether;

    /**
     * @dev Percentages are expressed as a ratio where 100000 is the denominator.
     * A large denominator allows for more precision, e.g representing 12.5%
     * can be done as 12500 / 100000
     */
    uint32 public constant PERCENTAGE_DENOMINATOR = 100000;

    /**
     * @dev Multiply a value by a given percentage. Converts the provided
     * uint128 value to uint256 to avoid any reverts on overflow.
     * @param value The value to multiply.
     * @param percentage The percentage, as a ratio of 100000.
     */
    function percOf(uint128 value, uint32 percentage) internal pure returns (uint256) {
        return (uint256(value) * percentage) / PERCENTAGE_DENOMINATOR;
    }

    /**
     * @dev Return a fraction as a percentage.
     * @param numerator The numerator limited to a uint128 value to prevent
     * phantom overflow.
     * @param denominator The denominator.
     * @return The percentage, as a ratio of 100000.
     */
    function asPerc(uint128 numerator, uint256 denominator) internal pure returns (uint32) {
        return SafeCast.toUint32((uint256(numerator) * PERCENTAGE_DENOMINATOR) / denominator);
    }

    /**
     * @dev Validate that a contract implements a given interface.
     * @param name The name of the contract, used in error messages.
     * @param target The address of the contract.
     * @param interfaceId The interface ID to check.
     */
    function validateContractInterface(
        string memory name,
        address target,
        bytes4 interfaceId
    ) internal view {
        if (bytes(name).length == 0) {
            revert ContractNameCannotBeEmpty();
        }
        if (target == address(0)) {
            revert TargetContractCannotBeZeroAddress(name);
        }
        if (interfaceId == bytes4(0)) {
            revert InterfaceIdCannotBeZeroBytes();
        }
        if (!ERC165(target).supportsInterface(interfaceId)) {
            revert TargetNotSupportInterface(name, interfaceId);
        }
    }
}

// SPDX-License-Identifier: Apache-2.0
pragma solidity ^0.8.18;

import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/utils/introspection/ERC165.sol";
import "@openzeppelin/contracts-upgradeable/access/Ownable2StepUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";

import "../Registries.sol";
import "../staking/Directory.sol";
import "../interfaces/epochs/IEpochsManager.sol";
import "../payments/ticketing/TicketingParameters.sol";

contract EpochsManager is IEpochsManager, Initializable, Ownable2StepUpgradeable, ERC165 {
    Directory public _directory;

    Registries public _registries;

    IERC721 public _rootSeekers;

    TicketingParameters public _ticketingParameters;

    /**
     * @notice Track seekers that have joined for a specific epoch.
     */
    mapping(uint256 => mapping(uint256 => address)) public activeSeekers;

    // Define all Epoch specific parameters here.
    // When initializing an epoch, these parameters are read,
    // along with parameters from the other contracts to create the
    // new epoch.

    /**
     * @notice A mapping of all epochs that have been initialized.
     */
    mapping(uint256 => Epoch) public epochs;

    /**
     * @notice The block number since the first epoch can be initialized.
     */
    uint256 public initialEpoch;

    /**
     * @notice The duration in blocks an epoch will last for.
     */
    uint256 public epochDuration;

    /**
     * @notice The value of the integer used as the current
     * epoch's identifier. This value is incremented as each epoch
     * is initialized.
     */
    uint256 public currentIteration;

    event NewEpoch(uint256 indexed epochId);
    event EpochJoined(uint256 indexed epochId, address indexed node, uint256 indexed seekerId);
    event InitialEpochUpdated(uint256 initialEpoch);
    event EpochDurationUpdated(uint256 epochDuration);

    error SeekerOwnerMismatch();
    error InitialEpochCannotBeZero();
    error EpochDurationCannotBeZero();
    error DirectoryCannotBeZeroAddress();
    error RegistriesCannotBeZeroAddress();
    error RootSeekerCannotBeZeroAddress();
    error EpochHasNotEnded(uint256 epochId);
    error SeekerAccountCannotBeZeroAddress();
    error TicketingParametersCannotBeZeroAddress();
    error SeekerAlreadyJoinedEpoch(uint256 epochId, uint256 seekerId);
    error InitialEpochNotYetReady(uint256 expectedBlock, uint256 currentBlock);

    function initialize(
        IERC721 rootSeekers,
        Directory directory,
        Registries registries,
        TicketingParameters ticketingParameters,
        uint256 _initialEpoch,
        uint256 _epochDuration
    ) external initializer {
        if (address(rootSeekers) == address(0)) {
            revert RootSeekerCannotBeZeroAddress();
        }

        SyloUtils.validateContractInterface(
            "Directory",
            address(directory),
            type(IDirectory).interfaceId
        );

        SyloUtils.validateContractInterface(
            "Registries",
            address(registries),
            type(IRegistries).interfaceId
        );

        SyloUtils.validateContractInterface(
            "TicketingParameters",
            address(ticketingParameters),
            type(ITicketingParameters).interfaceId
        );

        Ownable2StepUpgradeable.__Ownable2Step_init();

        _rootSeekers = rootSeekers;
        _directory = directory;
        _registries = registries;
        _ticketingParameters = ticketingParameters;

        initialEpoch = _initialEpoch;
        epochDuration = _epochDuration;
    }

    /**
     * @notice Returns true if the contract implements the interface defined by
     * `interfaceId` from ERC165.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
        return interfaceId == type(IEpochsManager).interfaceId;
    }

    /**
     * @notice Call this to initialize the next epoch. On success, a `NewEpoch` event
     * will be emitted.
     * @dev The function will read the current set of network parameters, and store
     * the parameters in a new Epoch struct. The end block of the current epoch
     * will also be set to a non-zero value.
     */
    function initializeEpoch() external returns (uint256) {
        if (currentIteration == 0 && initialEpoch > block.number) {
            revert InitialEpochNotYetReady(initialEpoch, block.number);
        }

        Epoch storage current = epochs[currentIteration];

        uint256 end = current.startBlock + current.duration;
        if (end > block.number) {
            revert EpochHasNotEnded(currentIteration);
        }

        (
            uint256 faceValue,
            uint128 baseLiveWinProb,
            uint128 expiredWinProb,
            uint256 ticketDuration,
            uint32 decayRate
        ) = _ticketingParameters.getTicketingParameters();

        uint256 nextEpochId = getNextEpochId();

        epochs[nextEpochId] = Epoch(
            block.number,
            epochDuration,
            0,
            _registries.defaultPayoutPercentage(),
            decayRate,
            faceValue,
            baseLiveWinProb,
            expiredWinProb,
            ticketDuration
        );

        current.endBlock = block.number;

        currentIteration = nextEpochId;

        _directory.setCurrentDirectory(nextEpochId);

        emit NewEpoch(nextEpochId);

        return nextEpochId;
    }

    /**
     * @notice Set the first epoch starting block. Only callable by the owner.
     * @param _initialEpoch The block number when the first epoch can be initialized.
     */
    function setInitialEpoch(uint256 _initialEpoch) external onlyOwner {
        if (_initialEpoch == 0) {
            revert InitialEpochCannotBeZero();
        }
        initialEpoch = _initialEpoch;
        emit InitialEpochUpdated(_initialEpoch);
    }

    /**
     * @notice Set the epoch duration. Will take effect in the next epoch. Only
     * callable by the owner.
     * @param _epochDuration The epoch duration in number of blocks.
     */
    function setEpochDuration(uint256 _epochDuration) external onlyOwner {
        if (_epochDuration == 0) {
            revert EpochDurationCannotBeZero();
        }
        epochDuration = _epochDuration;
        emit EpochDurationUpdated(epochDuration);
    }

    /**
     * @notice Retrieve the parameters for the current epoch.
     * @return The current Epoch parameters.
     */
    function getCurrentActiveEpoch() external view returns (uint256, Epoch memory) {
        return (currentIteration, epochs[currentIteration]);
    }

    /**
     * @notice Nodes should call this to join the next epoch. It will
     * initialize the next reward pool and set the stake for the next directory.
     * @dev This is a proxy function for `initalizeNextRewardPool` and
     * `joinNextDirectory`.
     */
    function joinNextEpoch() external {
        Registries.Registry memory registry = _registries.getRegistry(msg.sender);

        // validate the node's seeker ownership
        if (registry.seekerAccount == address(0)) {
            revert SeekerAccountCannotBeZeroAddress();
        }

        uint256 seekerId = registry.seekerId;

        address owner = _rootSeekers.ownerOf(seekerId);
        if (registry.seekerAccount != owner) {
            revert SeekerOwnerMismatch();
        }

        uint256 nextEpoch = getNextEpochId();
        if (activeSeekers[nextEpoch][seekerId] != address(0)) {
            revert SeekerAlreadyJoinedEpoch(nextEpoch, seekerId);
        }

        activeSeekers[nextEpoch][seekerId] = msg.sender;

        _directory._rewardsManager().initializeNextRewardPool(msg.sender);
        _directory.joinNextDirectory(msg.sender, seekerId);

        emit EpochJoined(nextEpoch, msg.sender, seekerId);
    }

    /**
     * @notice Retrieve the epoch parameter for the given id.
     * @param epochId The id of the epoch to retrieve.
     * @return The epoch parameters associated with the id.
     */
    function getEpoch(uint256 epochId) external view returns (Epoch memory) {
        return epochs[epochId];
    }

    /**
     * @notice Retrieve the integer value that will be used for the
     * next epoch id.
     * @return The next epoch id identifier.
     */
    function getNextEpochId() public view returns (uint256) {
        return currentIteration + 1;
    }
}

// SPDX-License-Identifier: Apache-2.0
pragma solidity ^0.8.18;

import "@openzeppelin/contracts-upgradeable/access/Ownable2StepUpgradeable.sol";

/**
 * @dev Contract module which provides a basic access control mechanism, where
 * there is an list of public managers who may be added or removed.
 *
 * This module is used through inheritance. It will make available the modifier
 * `onlyManager`, which can be applied to your functions to restrict their use to
 * other contracts which have explicitly been added.
 */
abstract contract Manageable is Ownable2StepUpgradeable {
    /**
     * @dev Tracks the managers added to this contract, where they key is the
     * address of the managing contract, and the value is the block the manager was added in.
     * We use this mapping to restrict access to those functions in a similar
     * fashion to the onlyOwner construct.
     */
    mapping(address => uint256) public managers;

    error OnlyManagers();
    error ManagerCannotBeZeroAddress();

    /**
     * @notice Adds a manager to this contract. Only callable by the owner.
     * @param manager The address of the manager contract.
     */
    function addManager(address manager) external onlyOwner {
        if (manager == address(0)) {
            revert ManagerCannotBeZeroAddress();
        }
        managers[manager] = block.number;
    }

    /**
     * @notice Removes a manager from this contract. Only callable by the owner.
     * @param manager The address of the manager contract.
     */
    function removeManager(address manager) external onlyOwner {
        delete managers[manager];
    }

    /**
     * @dev This modifier allows us to specify that certain contracts have
     * special privileges to call restricted functions.
     */
    modifier onlyManager() {
        if (managers[msg.sender] == 0) {
            revert OnlyManagers();
        }
        _;
    }

    // Reserve storage slots for future variables
    uint256[49] private __gap;
}

// SPDX-License-Identifier: Apache-2.0
pragma solidity ^0.8.18;

interface IRegistries {
    struct Registry {
        // Percentage of a tickets value that will be rewarded to
        // delegated stakers expressed as a fraction of 100000.
        // This value is currently locked to the default payout percentage
        // until epochs are implemented.
        uint32 payoutPercentage;
        // Public http/s endpoint to retrieve additional metadata
        // about the node.
        // The current metadata schema is as follows:
        //  { name: string, multiaddrs: string[] }
        string publicEndpoint;
        // The account which owns a seeker that will be used to
        // operate the Node for this registry.
        address seekerAccount;
        // The id of the seeker used to operate the node. The owner
        // of this id should be the seeker account.
        uint256 seekerId;
    }

    function register(string calldata publicEndpoint) external;

    function setDefaultPayoutPercentage(uint32 _defaultPayoutPercentage) external;

    function setSeekerAccount(
        address seekerAccount,
        uint256 seekerId,
        bytes32 nonce,
        bytes calldata signature
    ) external;

    function revokeSeekerAccount(address node) external;

    function getRegistry(address account) external view returns (Registry memory);

    function getNodes() external view returns (address[] memory);

    function getRegistries(
        uint256 start,
        uint256 end
    ) external view returns (address[] memory, Registry[] memory);

    function getTotalNodes() external view returns (uint256);
}

// SPDX-License-Identifier: Apache-2.0
pragma solidity ^0.8.18;

import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts-upgradeable/access/Ownable2StepUpgradeable.sol";

import "../SyloToken.sol";
import "../libraries/SyloUtils.sol";
import "../SeekerPowerOracle.sol";
import "../epochs/EpochsManager.sol";
import "../payments/ticketing/RewardsManager.sol";
import "../interfaces/staking/IStakingManager.sol";

/**
 * @notice Manages stakes and delegated stakes for Nodes. Holding
 * staked Sylo is necessary for a Node to participate in the
 * Sylo Network. The stake is used in stake-weighted scan function,
 * and delegated stakers are rewarded on a pro-rata basis.
 */
contract StakingManager is IStakingManager, Initializable, Ownable2StepUpgradeable, ERC165 {
    /** ERC 20 compatible token we are dealing with */
    IERC20 public _token;

    /**
     * @notice Rewards Manager contract. Any changes to stake will automatically
     * trigger a claim to any outstanding rewards.
     */
    RewardsManager public _rewardsManager;

    EpochsManager public _epochsManager;

    SeekerPowerOracle public _seekerPowerOracle;

    /**
     * @notice Tracks the managed stake for every Node.
     */
    mapping(address => Stake) public stakes;

    /** @notice Tracks overall total stake held by this contract */
    uint256 public totalManagedStake;

    /**
     * @notice Tracks funds that are in the process of being unlocked. This
     * is indexed by a key that hashes both the address of the staked Node and
     * the address of the staker.
     */
    mapping(bytes32 => Unlock) public unlockings;

    /**
     * @notice The number of blocks a user must wait after calling "unlock"
     * before they can withdraw their stake
     */
    uint256 public unlockDuration;

    /**
     * @notice Minimum amount of stake that a Node needs to stake
     * against itself in order to participate in the network. This is
     * represented as a percentage of the Node's total stake, where
     * the value is a ratio of 10000.
     */
    uint32 public minimumStakeProportion;

    /**
     * @notice The multiplier used in determining a Seeker's staking
     * capacity based on its power level.
     */
    uint256 public seekerPowerMultiplier;

    event UnlockDurationUpdated(uint256 unlockDuration);
    event MinimumStakeProportionUpdated(uint256 minimumStakeProportion);
    event SeekerPowerMultiplierUpdated(uint256 seekerPowerMultipler);

    error NoStakeToUnlock();
    error StakeNotYetUnlocked();
    error CannotStakeZeroAmount();
    error CannotUnlockZeroAmount();
    error TokenCannotBeZeroAddress();
    error StakeeCannotBeZeroAddress();
    error UnlockDurationCannotBeZero();
    error CannotCancelUnlockZeroAmount();
    error CannotUnlockMoreThanStaked(uint256 stakeAmount, uint256 unlockAmount);
    error StakeCapacityReached(uint256 maxCapacity, uint256 currentCapacity);
    error SeekerPowerNotRegistered(uint256 seekerId);

    function initialize(
        IERC20 token,
        RewardsManager rewardsManager,
        EpochsManager epochsManager,
        SeekerPowerOracle seekerPowerOracle,
        uint256 _unlockDuration,
        uint32 _minimumStakeProportion,
        uint256 _seekerPowerMultiplier
    ) external initializer {
        if (address(token) == address(0)) {
            revert TokenCannotBeZeroAddress();
        }

        SyloUtils.validateContractInterface(
            "RewardsManager",
            address(rewardsManager),
            type(IRewardsManager).interfaceId
        );

        SyloUtils.validateContractInterface(
            "EpochsManager",
            address(epochsManager),
            type(IEpochsManager).interfaceId
        );

        SyloUtils.validateContractInterface(
            "SeekerPowerOracle",
            address(seekerPowerOracle),
            type(ISeekerPowerOracle).interfaceId
        );

        if (_unlockDuration == 0) {
            revert UnlockDurationCannotBeZero();
        }

        Ownable2StepUpgradeable.__Ownable2Step_init();

        _token = token;
        _rewardsManager = rewardsManager;
        _epochsManager = epochsManager;
        _seekerPowerOracle = seekerPowerOracle;
        unlockDuration = _unlockDuration;
        minimumStakeProportion = _minimumStakeProportion;
        seekerPowerMultiplier = _seekerPowerMultiplier;
    }

    /**
     * @notice Returns true if the contract implements the interface defined by
     * `interfaceId` from ERC165.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
        return interfaceId == type(IStakingManager).interfaceId;
    }

    /**
     * @notice Sets the unlock duration for stakes. Only callable by
     * the owner.
     * @param _unlockDuration The unlock duration in number of blocks.
     */
    function setUnlockDuration(uint256 _unlockDuration) external onlyOwner {
        if (_unlockDuration == 0) {
            revert UnlockDurationCannotBeZero();
        }

        unlockDuration = _unlockDuration;
        emit UnlockDurationUpdated(_unlockDuration);
    }

    function setSeekerPowerMultiplier(uint256 _seekerPowerMultiplier) external onlyOwner {
        seekerPowerMultiplier = _seekerPowerMultiplier;
        emit SeekerPowerMultiplierUpdated(seekerPowerMultiplier);
    }

    /**
     * @notice Sets the minimum stake proportion for Nodes. Only callable by
     * the owner.
     * @param _minimumStakeProportion The minimum stake proportion in SOLO.
     */
    function setMinimumStakeProportion(uint32 _minimumStakeProportion) external onlyOwner {
        minimumStakeProportion = _minimumStakeProportion;
        emit MinimumStakeProportionUpdated(_minimumStakeProportion);
    }

    /**
     * @notice Called by Nodes and delegated stakers to add stake.
     * This function will fail under the following conditions:
     *   - If the Node address is invalid
     *   - If the specified stake value is zero
     *   - If the additional stake causes the Node to fail to meet the
     *     minimum stake proportion requirement.
     * @param amount The amount of stake to add in SOLO.
     * @param stakee The address of the staked Node.
     */
    function addStake(uint256 amount, address stakee) external {
        if (stakee == address(0)) {
            revert StakeeCannotBeZeroAddress();
        }
        if (amount == 0) {
            revert CannotStakeZeroAmount();
        }

        _addStake(amount, stakee);
        SafeERC20.safeTransferFrom(_token, msg.sender, address(this), amount);
    }

    function _addStake(uint256 amount, address stakee) internal {
        // automatically move any pending rewards generated by their existing stake
        _rewardsManager.updatePendingRewards(stakee, msg.sender);

        uint256 currentEpochId = _epochsManager.currentIteration();

        Stake storage stake = stakes[stakee];

        uint256 currentStake = getCurrentStakerAmount(stakee, msg.sender);

        stake.stakeEntries[msg.sender] = StakeEntry(
            currentStake + amount,
            block.number,
            currentEpochId
        );

        stake.totalManagedStake = stake.totalManagedStake + amount;
        totalManagedStake = totalManagedStake + amount;
    }

    /**
     * @notice Call this function to begin the unlocking process. Calling this
     * will trigger an automatic claim of any outstanding staking rewards. Any
     * stake that was already in the unlocking phase will have the specified
     * amount added to it, and its duration refreshed. This function will fail
     * under the following conditions:
     *   - If no stake exists for the caller
     *   - If the unlock amount is zero
     *   - If the unlock amount is more than what is staked
     * Note: If calling as a Node, this function will *not* revert if it causes
     * the Node to fail to meet the minimum stake proportion. However it will still
     * prevent the Node from participating in the network until the minimum is met
     * again.
     * @param amount The amount of stake to unlock in SOLO.
     * @param stakee The address of the staked Node.
     */
    function unlockStake(uint256 amount, address stakee) external returns (uint256) {
        if (stakee == address(0)) {
            revert StakeeCannotBeZeroAddress();
        }
        if (amount == 0) {
            revert CannotUnlockZeroAmount();
        }

        uint256 currentStake = getCurrentStakerAmount(stakee, msg.sender);

        if (currentStake == 0) {
            revert NoStakeToUnlock();
        }
        if (currentStake < amount) {
            revert CannotUnlockMoreThanStaked(currentStake, amount);
        }

        // automatically move any pending rewards generated by their existing stake
        _rewardsManager.updatePendingRewards(stakee, msg.sender);

        uint256 currentEpochId = _epochsManager.currentIteration();

        Stake storage stake = stakes[stakee];

        stake.stakeEntries[msg.sender] = StakeEntry(
            currentStake - amount,
            block.number,
            currentEpochId
        );

        stake.totalManagedStake = stake.totalManagedStake - amount;
        totalManagedStake = totalManagedStake - amount;

        bytes32 key = getKey(stakee, msg.sender);

        // Keep track of when the stake can be withdrawn
        Unlock storage unlock = unlockings[key];

        uint256 unlockAt = block.number + unlockDuration;
        if (unlock.unlockAt < unlockAt) {
            unlock.unlockAt = unlockAt;
        }

        unlock.amount = unlock.amount + amount;

        return unlockAt;
    }

    /**
     * @notice Call this function to withdraw stake that has finished unlocking.
     * This will fail if the stake has not yet unlocked.
     * @param stakee The address of the staked Node.
     */
    function withdrawStake(address stakee) external {
        if (stakee == address(0)) {
            revert StakeeCannotBeZeroAddress();
        }

        bytes32 key = getKey(stakee, msg.sender);

        Unlock storage unlock = unlockings[key];

        if (unlock.unlockAt >= block.number) {
            revert StakeNotYetUnlocked();
        }

        uint256 amount = unlock.amount;

        delete unlockings[key];

        SafeERC20.safeTransfer(_token, msg.sender, amount);
    }

    /**
     * @notice Call this function to cancel any stake that is in the process
     * of unlocking. As this essentially adds back stake to the Node, this
     * will trigger an automatic claim of any outstanding staking rewards.
     * If the specified amount to cancel is greater than the stake that is
     * currently being unlocked, it will cancel the maximum stake possible.
     * @param amount The amount of unlocking stake to cancel in SOLO.
     * @param stakee The address of the staked Node.
     */
    function cancelUnlocking(uint256 amount, address stakee) external {
        if (stakee == address(0)) {
            revert StakeeCannotBeZeroAddress();
        }
        if (amount == 0) {
            revert CannotCancelUnlockZeroAmount();
        }

        bytes32 key = getKey(stakee, msg.sender);

        Unlock storage unlock = unlockings[key];

        if (amount >= unlock.amount) {
            amount = unlock.amount;
            delete unlockings[key];
        } else {
            unlock.amount = unlock.amount - amount;
        }

        _addStake(amount, stakee);
    }

    /**
     * @notice This function determines the staking capacity of
     * a Seeker based on its power level. The method will revert if
     * the Seeker's power level has not been registered with the oracle.
     *
     * Currently the algorithm is as follows:
     *    staking_capacity = seeker_power * seeker_power_multiplier;
     */
    function calculateCapacityFromSeekerPower(uint256 seekerId) external view returns (uint256) {
        uint256 seekerPower = _seekerPowerOracle.getSeekerPower(seekerId);
        if (seekerPower == 0) {
            revert SeekerPowerNotRegistered(seekerId);
        }

        // If the Seeker Power is already
        // at the maximum sylo, then we just return the max sylo value directly.
        if (seekerPower >= SyloUtils.MAX_SYLO) {
            return SyloUtils.MAX_SYLO;
        }

        uint256 capacity = seekerPower * seekerPowerMultiplier;

        return capacity > SyloUtils.MAX_SYLO ? SyloUtils.MAX_SYLO : capacity;
    }

    /**
     * @notice This function can be used to a determine a Node's staking capacity,
     * based on the minimum stake proportion constant.
     * @param stakee The address of the staked Node.
     */
    function calculateCapacityFromMinStakingProportion(address stakee) public view returns (uint256) {
        if (stakee == address(0)) {
            revert StakeeCannotBeZeroAddress();
        }

        Stake storage stake = stakes[stakee];

        uint256 currentlyOwnedStake = stake.stakeEntries[stakee].amount;
        return (currentlyOwnedStake * SyloUtils.PERCENTAGE_DENOMINATOR) /
            minimumStakeProportion;
    }

    /**
     * @notice This function should be called by clients to determine how much
     * additional delegated stake can be allocated to a Node via an addStake or
     * cancelUnlocking call. This is useful to avoid a revert due to
     * the minimum stake proportion requirement not being met from the additional stake.
     * @param stakee The address of the staked Node.
     */
    function calculateMaxAdditionalDelegatedStake(address stakee) external view returns (uint256) {
        uint256 totalMaxStake = calculateCapacityFromMinStakingProportion(stakee);

        Stake storage stake = stakes[stakee];

        if (totalMaxStake < stake.totalManagedStake) {
            revert StakeCapacityReached(totalMaxStake, stake.totalManagedStake);
        }

        return totalMaxStake - stake.totalManagedStake;
    }

    /**
     * @notice Retrieve the key used to index a stake entry. The key is a hash
     * which takes both address of the Node and the staker as input.
     * @param stakee The address of the staked Node.
     * @param staker The address of the staker.
     * @return A byte-array representing the key.
     */
    function getKey(address stakee, address staker) public pure returns (bytes32) {
        return keccak256(abi.encodePacked(stakee, staker));
    }

    /**
     * @notice Retrieve the total stake being managed by this contract.
     * @return The total amount of managed stake in SOLO.
     */
    function getTotalManagedStake() external view returns (uint256) {
        return totalManagedStake;
    }

    /**
     * @notice Retrieve a stake entry.
     * @param stakee The address of the staked Node.
     * @param staker The address of the staker.
     * @return The stake entry.
     */
    function getStakeEntry(
        address stakee,
        address staker
    ) external view returns (StakeEntry memory) {
        return stakes[stakee].stakeEntries[staker];
    }

    /**
     * @notice Retrieve the total amount of SOLO staked against a Node.
     * @param stakee The address of the staked Node.
     * @return The amount of staked SOLO.
     */
    function getStakeeTotalManagedStake(address stakee) external view returns (uint256) {
        return stakes[stakee].totalManagedStake;
    }

    /**
     * @notice Check if a Node is meeting the minimum stake proportion requirement.
     * @param stakee The address of the staked Node.
     * @return True if the Node is meeting minimum stake proportion requirement.
     */
    function checkMinimumStakeProportion(address stakee) public view returns (bool) {
        if (stakee == address(0)) {
            revert StakeeCannotBeZeroAddress();
        }

        Stake storage stake = stakes[stakee];

        uint256 currentlyOwnedStake = stake.stakeEntries[stakee].amount;
        uint32 ownedStakeProportion = SyloUtils.asPerc(
            SafeCast.toUint128(currentlyOwnedStake),
            stake.totalManagedStake
        );

        return ownedStakeProportion >= minimumStakeProportion;
    }

    /**
     * @notice Retrieve the current amount of SOLO staked against a Node by
     * a specified staker.
     * @param stakee The address of the staked Node.
     * @param staker The address of the staker.
     * @return The amount of staked SOLO.
     */
    function getCurrentStakerAmount(address stakee, address staker) public view returns (uint256) {
        return stakes[stakee].stakeEntries[staker].amount;
    }
}

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

pragma solidity ^0.8.1;

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

        return account.code.length > 0;
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

pragma solidity ^0.8.0;

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

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

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

pragma solidity ^0.8.0;

import "./math/Math.sol";
import "./math/SignedMath.sol";

/**
 * @dev String operations.
 */
library Strings {
    bytes16 private constant _SYMBOLS = "0123456789abcdef";
    uint8 private constant _ADDRESS_LENGTH = 20;

    /**
     * @dev Converts a `uint256` to its ASCII `string` decimal representation.
     */
    function toString(uint256 value) internal pure returns (string memory) {
        unchecked {
            uint256 length = Math.log10(value) + 1;
            string memory buffer = new string(length);
            uint256 ptr;
            /// @solidity memory-safe-assembly
            assembly {
                ptr := add(buffer, add(32, length))
            }
            while (true) {
                ptr--;
                /// @solidity memory-safe-assembly
                assembly {
                    mstore8(ptr, byte(mod(value, 10), _SYMBOLS))
                }
                value /= 10;
                if (value == 0) break;
            }
            return buffer;
        }
    }

    /**
     * @dev Converts a `int256` to its ASCII `string` decimal representation.
     */
    function toString(int256 value) internal pure returns (string memory) {
        return string(abi.encodePacked(value < 0 ? "-" : "", toString(SignedMath.abs(value))));
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
     */
    function toHexString(uint256 value) internal pure returns (string memory) {
        unchecked {
            return toHexString(value, Math.log256(value) + 1);
        }
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.
     */
    function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
        bytes memory buffer = new bytes(2 * length + 2);
        buffer[0] = "0";
        buffer[1] = "x";
        for (uint256 i = 2 * length + 1; i > 1; --i) {
            buffer[i] = _SYMBOLS[value & 0xf];
            value >>= 4;
        }
        require(value == 0, "Strings: hex length insufficient");
        return string(buffer);
    }

    /**
     * @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal representation.
     */
    function toHexString(address addr) internal pure returns (string memory) {
        return toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH);
    }

    /**
     * @dev Returns true if the two strings are equal.
     */
    function equal(string memory a, string memory b) internal pure returns (bool) {
        return keccak256(bytes(a)) == keccak256(bytes(b));
    }
}

// SPDX-License-Identifier: BSD-4-Clause
/*
 * ABDK Math 64.64 Smart Contract Library.  Copyright © 2019 by ABDK Consulting.
 * Author: Mikhail Vladimirov <mikhail.vladimirov@gmail.com>
 */
pragma solidity ^0.8.0;

/**
 * Smart contract library of mathematical functions operating with signed
 * 64.64-bit fixed point numbers.  Signed 64.64-bit fixed point number is
 * basically a simple fraction whose numerator is signed 128-bit integer and
 * denominator is 2^64.  As long as denominator is always the same, there is no
 * need to store it, thus in Solidity signed 64.64-bit fixed point numbers are
 * represented by int128 type holding only the numerator.
 */
library ABDKMath64x64 {
  /*
   * Minimum value signed 64.64-bit fixed point number may have. 
   */
  int128 private constant MIN_64x64 = -0x80000000000000000000000000000000;

  /*
   * Maximum value signed 64.64-bit fixed point number may have. 
   */
  int128 private constant MAX_64x64 = 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF;

  /**
   * Convert signed 256-bit integer number into signed 64.64-bit fixed point
   * number.  Revert on overflow.
   *
   * @param x signed 256-bit integer number
   * @return signed 64.64-bit fixed point number
   */
  function fromInt (int256 x) internal pure returns (int128) {
    unchecked {
      require (x >= -0x8000000000000000 && x <= 0x7FFFFFFFFFFFFFFF);
      return int128 (x << 64);
    }
  }

  /**
   * Convert signed 64.64 fixed point number into signed 64-bit integer number
   * rounding down.
   *
   * @param x signed 64.64-bit fixed point number
   * @return signed 64-bit integer number
   */
  function toInt (int128 x) internal pure returns (int64) {
    unchecked {
      return int64 (x >> 64);
    }
  }

  /**
   * Convert unsigned 256-bit integer number into signed 64.64-bit fixed point
   * number.  Revert on overflow.
   *
   * @param x unsigned 256-bit integer number
   * @return signed 64.64-bit fixed point number
   */
  function fromUInt (uint256 x) internal pure returns (int128) {
    unchecked {
      require (x <= 0x7FFFFFFFFFFFFFFF);
      return int128 (int256 (x << 64));
    }
  }

  /**
   * Convert signed 64.64 fixed point number into unsigned 64-bit integer
   * number rounding down.  Revert on underflow.
   *
   * @param x signed 64.64-bit fixed point number
   * @return unsigned 64-bit integer number
   */
  function toUInt (int128 x) internal pure returns (uint64) {
    unchecked {
      require (x >= 0);
      return uint64 (uint128 (x >> 64));
    }
  }

  /**
   * Convert signed 128.128 fixed point number into signed 64.64-bit fixed point
   * number rounding down.  Revert on overflow.
   *
   * @param x signed 128.128-bin fixed point number
   * @return signed 64.64-bit fixed point number
   */
  function from128x128 (int256 x) internal pure returns (int128) {
    unchecked {
      int256 result = x >> 64;
      require (result >= MIN_64x64 && result <= MAX_64x64);
      return int128 (result);
    }
  }

  /**
   * Convert signed 64.64 fixed point number into signed 128.128 fixed point
   * number.
   *
   * @param x signed 64.64-bit fixed point number
   * @return signed 128.128 fixed point number
   */
  function to128x128 (int128 x) internal pure returns (int256) {
    unchecked {
      return int256 (x) << 64;
    }
  }

  /**
   * Calculate x + y.  Revert on overflow.
   *
   * @param x signed 64.64-bit fixed point number
   * @param y signed 64.64-bit fixed point number
   * @return signed 64.64-bit fixed point number
   */
  function add (int128 x, int128 y) internal pure returns (int128) {
    unchecked {
      int256 result = int256(x) + y;
      require (result >= MIN_64x64 && result <= MAX_64x64);
      return int128 (result);
    }
  }

  /**
   * Calculate x - y.  Revert on overflow.
   *
   * @param x signed 64.64-bit fixed point number
   * @param y signed 64.64-bit fixed point number
   * @return signed 64.64-bit fixed point number
   */
  function sub (int128 x, int128 y) internal pure returns (int128) {
    unchecked {
      int256 result = int256(x) - y;
      require (result >= MIN_64x64 && result <= MAX_64x64);
      return int128 (result);
    }
  }

  /**
   * Calculate x * y rounding down.  Revert on overflow.
   *
   * @param x signed 64.64-bit fixed point number
   * @param y signed 64.64-bit fixed point number
   * @return signed 64.64-bit fixed point number
   */
  function mul (int128 x, int128 y) internal pure returns (int128) {
    unchecked {
      int256 result = int256(x) * y >> 64;
      require (result >= MIN_64x64 && result <= MAX_64x64);
      return int128 (result);
    }
  }

  /**
   * Calculate x * y rounding towards zero, where x is signed 64.64 fixed point
   * number and y is signed 256-bit integer number.  Revert on overflow.
   *
   * @param x signed 64.64 fixed point number
   * @param y signed 256-bit integer number
   * @return signed 256-bit integer number
   */
  function muli (int128 x, int256 y) internal pure returns (int256) {
    unchecked {
      if (x == MIN_64x64) {
        require (y >= -0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF &&
          y <= 0x1000000000000000000000000000000000000000000000000);
        return -y << 63;
      } else {
        bool negativeResult = false;
        if (x < 0) {
          x = -x;
          negativeResult = true;
        }
        if (y < 0) {
          y = -y; // We rely on overflow behavior here
          negativeResult = !negativeResult;
        }
        uint256 absoluteResult = mulu (x, uint256 (y));
        if (negativeResult) {
          require (absoluteResult <=
            0x8000000000000000000000000000000000000000000000000000000000000000);
          return -int256 (absoluteResult); // We rely on overflow behavior here
        } else {
          require (absoluteResult <=
            0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);
          return int256 (absoluteResult);
        }
      }
    }
  }

  /**
   * Calculate x * y rounding down, where x is signed 64.64 fixed point number
   * and y is unsigned 256-bit integer number.  Revert on overflow.
   *
   * @param x signed 64.64 fixed point number
   * @param y unsigned 256-bit integer number
   * @return unsigned 256-bit integer number
   */
  function mulu (int128 x, uint256 y) internal pure returns (uint256) {
    unchecked {
      if (y == 0) return 0;

      require (x >= 0);

      uint256 lo = (uint256 (int256 (x)) * (y & 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)) >> 64;
      uint256 hi = uint256 (int256 (x)) * (y >> 128);

      require (hi <= 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);
      hi <<= 64;

      require (hi <=
        0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF - lo);
      return hi + lo;
    }
  }

  /**
   * Calculate x / y rounding towards zero.  Revert on overflow or when y is
   * zero.
   *
   * @param x signed 64.64-bit fixed point number
   * @param y signed 64.64-bit fixed point number
   * @return signed 64.64-bit fixed point number
   */
  function div (int128 x, int128 y) internal pure returns (int128) {
    unchecked {
      require (y != 0);
      int256 result = (int256 (x) << 64) / y;
      require (result >= MIN_64x64 && result <= MAX_64x64);
      return int128 (result);
    }
  }

  /**
   * Calculate x / y rounding towards zero, where x and y are signed 256-bit
   * integer numbers.  Revert on overflow or when y is zero.
   *
   * @param x signed 256-bit integer number
   * @param y signed 256-bit integer number
   * @return signed 64.64-bit fixed point number
   */
  function divi (int256 x, int256 y) internal pure returns (int128) {
    unchecked {
      require (y != 0);

      bool negativeResult = false;
      if (x < 0) {
        x = -x; // We rely on overflow behavior here
        negativeResult = true;
      }
      if (y < 0) {
        y = -y; // We rely on overflow behavior here
        negativeResult = !negativeResult;
      }
      uint128 absoluteResult = divuu (uint256 (x), uint256 (y));
      if (negativeResult) {
        require (absoluteResult <= 0x80000000000000000000000000000000);
        return -int128 (absoluteResult); // We rely on overflow behavior here
      } else {
        require (absoluteResult <= 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);
        return int128 (absoluteResult); // We rely on overflow behavior here
      }
    }
  }

  /**
   * Calculate x / y rounding towards zero, where x and y are unsigned 256-bit
   * integer numbers.  Revert on overflow or when y is zero.
   *
   * @param x unsigned 256-bit integer number
   * @param y unsigned 256-bit integer number
   * @return signed 64.64-bit fixed point number
   */
  function divu (uint256 x, uint256 y) internal pure returns (int128) {
    unchecked {
      require (y != 0);
      uint128 result = divuu (x, y);
      require (result <= uint128 (MAX_64x64));
      return int128 (result);
    }
  }

  /**
   * Calculate -x.  Revert on overflow.
   *
   * @param x signed 64.64-bit fixed point number
   * @return signed 64.64-bit fixed point number
   */
  function neg (int128 x) internal pure returns (int128) {
    unchecked {
      require (x != MIN_64x64);
      return -x;
    }
  }

  /**
   * Calculate |x|.  Revert on overflow.
   *
   * @param x signed 64.64-bit fixed point number
   * @return signed 64.64-bit fixed point number
   */
  function abs (int128 x) internal pure returns (int128) {
    unchecked {
      require (x != MIN_64x64);
      return x < 0 ? -x : x;
    }
  }

  /**
   * Calculate 1 / x rounding towards zero.  Revert on overflow or when x is
   * zero.
   *
   * @param x signed 64.64-bit fixed point number
   * @return signed 64.64-bit fixed point number
   */
  function inv (int128 x) internal pure returns (int128) {
    unchecked {
      require (x != 0);
      int256 result = int256 (0x100000000000000000000000000000000) / x;
      require (result >= MIN_64x64 && result <= MAX_64x64);
      return int128 (result);
    }
  }

  /**
   * Calculate arithmetics average of x and y, i.e. (x + y) / 2 rounding down.
   *
   * @param x signed 64.64-bit fixed point number
   * @param y signed 64.64-bit fixed point number
   * @return signed 64.64-bit fixed point number
   */
  function avg (int128 x, int128 y) internal pure returns (int128) {
    unchecked {
      return int128 ((int256 (x) + int256 (y)) >> 1);
    }
  }

  /**
   * Calculate geometric average of x and y, i.e. sqrt (x * y) rounding down.
   * Revert on overflow or in case x * y is negative.
   *
   * @param x signed 64.64-bit fixed point number
   * @param y signed 64.64-bit fixed point number
   * @return signed 64.64-bit fixed point number
   */
  function gavg (int128 x, int128 y) internal pure returns (int128) {
    unchecked {
      int256 m = int256 (x) * int256 (y);
      require (m >= 0);
      require (m <
          0x4000000000000000000000000000000000000000000000000000000000000000);
      return int128 (sqrtu (uint256 (m)));
    }
  }

  /**
   * Calculate x^y assuming 0^0 is 1, where x is signed 64.64 fixed point number
   * and y is unsigned 256-bit integer number.  Revert on overflow.
   *
   * @param x signed 64.64-bit fixed point number
   * @param y uint256 value
   * @return signed 64.64-bit fixed point number
   */
  function pow (int128 x, uint256 y) internal pure returns (int128) {
    unchecked {
      bool negative = x < 0 && y & 1 == 1;

      uint256 absX = uint128 (x < 0 ? -x : x);
      uint256 absResult;
      absResult = 0x100000000000000000000000000000000;

      if (absX <= 0x10000000000000000) {
        absX <<= 63;
        while (y != 0) {
          if (y & 0x1 != 0) {
            absResult = absResult * absX >> 127;
          }
          absX = absX * absX >> 127;

          if (y & 0x2 != 0) {
            absResult = absResult * absX >> 127;
          }
          absX = absX * absX >> 127;

          if (y & 0x4 != 0) {
            absResult = absResult * absX >> 127;
          }
          absX = absX * absX >> 127;

          if (y & 0x8 != 0) {
            absResult = absResult * absX >> 127;
          }
          absX = absX * absX >> 127;

          y >>= 4;
        }

        absResult >>= 64;
      } else {
        uint256 absXShift = 63;
        if (absX < 0x1000000000000000000000000) { absX <<= 32; absXShift -= 32; }
        if (absX < 0x10000000000000000000000000000) { absX <<= 16; absXShift -= 16; }
        if (absX < 0x1000000000000000000000000000000) { absX <<= 8; absXShift -= 8; }
        if (absX < 0x10000000000000000000000000000000) { absX <<= 4; absXShift -= 4; }
        if (absX < 0x40000000000000000000000000000000) { absX <<= 2; absXShift -= 2; }
        if (absX < 0x80000000000000000000000000000000) { absX <<= 1; absXShift -= 1; }

        uint256 resultShift = 0;
        while (y != 0) {
          require (absXShift < 64);

          if (y & 0x1 != 0) {
            absResult = absResult * absX >> 127;
            resultShift += absXShift;
            if (absResult > 0x100000000000000000000000000000000) {
              absResult >>= 1;
              resultShift += 1;
            }
          }
          absX = absX * absX >> 127;
          absXShift <<= 1;
          if (absX >= 0x100000000000000000000000000000000) {
              absX >>= 1;
              absXShift += 1;
          }

          y >>= 1;
        }

        require (resultShift < 64);
        absResult >>= 64 - resultShift;
      }
      int256 result = negative ? -int256 (absResult) : int256 (absResult);
      require (result >= MIN_64x64 && result <= MAX_64x64);
      return int128 (result);
    }
  }

  /**
   * Calculate sqrt (x) rounding down.  Revert if x < 0.
   *
   * @param x signed 64.64-bit fixed point number
   * @return signed 64.64-bit fixed point number
   */
  function sqrt (int128 x) internal pure returns (int128) {
    unchecked {
      require (x >= 0);
      return int128 (sqrtu (uint256 (int256 (x)) << 64));
    }
  }

  /**
   * Calculate binary logarithm of x.  Revert if x <= 0.
   *
   * @param x signed 64.64-bit fixed point number
   * @return signed 64.64-bit fixed point number
   */
  function log_2 (int128 x) internal pure returns (int128) {
    unchecked {
      require (x > 0);

      int256 msb = 0;
      int256 xc = x;
      if (xc >= 0x10000000000000000) { xc >>= 64; msb += 64; }
      if (xc >= 0x100000000) { xc >>= 32; msb += 32; }
      if (xc >= 0x10000) { xc >>= 16; msb += 16; }
      if (xc >= 0x100) { xc >>= 8; msb += 8; }
      if (xc >= 0x10) { xc >>= 4; msb += 4; }
      if (xc >= 0x4) { xc >>= 2; msb += 2; }
      if (xc >= 0x2) msb += 1;  // No need to shift xc anymore

      int256 result = msb - 64 << 64;
      uint256 ux = uint256 (int256 (x)) << uint256 (127 - msb);
      for (int256 bit = 0x8000000000000000; bit > 0; bit >>= 1) {
        ux *= ux;
        uint256 b = ux >> 255;
        ux >>= 127 + b;
        result += bit * int256 (b);
      }

      return int128 (result);
    }
  }

  /**
   * Calculate natural logarithm of x.  Revert if x <= 0.
   *
   * @param x signed 64.64-bit fixed point number
   * @return signed 64.64-bit fixed point number
   */
  function ln (int128 x) internal pure returns (int128) {
    unchecked {
      require (x > 0);

      return int128 (int256 (
          uint256 (int256 (log_2 (x))) * 0xB17217F7D1CF79ABC9E3B39803F2F6AF >> 128));
    }
  }

  /**
   * Calculate binary exponent of x.  Revert on overflow.
   *
   * @param x signed 64.64-bit fixed point number
   * @return signed 64.64-bit fixed point number
   */
  function exp_2 (int128 x) internal pure returns (int128) {
    unchecked {
      require (x < 0x400000000000000000); // Overflow

      if (x < -0x400000000000000000) return 0; // Underflow

      uint256 result = 0x80000000000000000000000000000000;

      if (x & 0x8000000000000000 > 0)
        result = result * 0x16A09E667F3BCC908B2FB1366EA957D3E >> 128;
      if (x & 0x4000000000000000 > 0)
        result = result * 0x1306FE0A31B7152DE8D5A46305C85EDEC >> 128;
      if (x & 0x2000000000000000 > 0)
        result = result * 0x1172B83C7D517ADCDF7C8C50EB14A791F >> 128;
      if (x & 0x1000000000000000 > 0)
        result = result * 0x10B5586CF9890F6298B92B71842A98363 >> 128;
      if (x & 0x800000000000000 > 0)
        result = result * 0x1059B0D31585743AE7C548EB68CA417FD >> 128;
      if (x & 0x400000000000000 > 0)
        result = result * 0x102C9A3E778060EE6F7CACA4F7A29BDE8 >> 128;
      if (x & 0x200000000000000 > 0)
        result = result * 0x10163DA9FB33356D84A66AE336DCDFA3F >> 128;
      if (x & 0x100000000000000 > 0)
        result = result * 0x100B1AFA5ABCBED6129AB13EC11DC9543 >> 128;
      if (x & 0x80000000000000 > 0)
        result = result * 0x10058C86DA1C09EA1FF19D294CF2F679B >> 128;
      if (x & 0x40000000000000 > 0)
        result = result * 0x1002C605E2E8CEC506D21BFC89A23A00F >> 128;
      if (x & 0x20000000000000 > 0)
        result = result * 0x100162F3904051FA128BCA9C55C31E5DF >> 128;
      if (x & 0x10000000000000 > 0)
        result = result * 0x1000B175EFFDC76BA38E31671CA939725 >> 128;
      if (x & 0x8000000000000 > 0)
        result = result * 0x100058BA01FB9F96D6CACD4B180917C3D >> 128;
      if (x & 0x4000000000000 > 0)
        result = result * 0x10002C5CC37DA9491D0985C348C68E7B3 >> 128;
      if (x & 0x2000000000000 > 0)
        result = result * 0x1000162E525EE054754457D5995292026 >> 128;
      if (x & 0x1000000000000 > 0)
        result = result * 0x10000B17255775C040618BF4A4ADE83FC >> 128;
      if (x & 0x800000000000 > 0)
        result = result * 0x1000058B91B5BC9AE2EED81E9B7D4CFAB >> 128;
      if (x & 0x400000000000 > 0)
        result = result * 0x100002C5C89D5EC6CA4D7C8ACC017B7C9 >> 128;
      if (x & 0x200000000000 > 0)
        result = result * 0x10000162E43F4F831060E02D839A9D16D >> 128;
      if (x & 0x100000000000 > 0)
        result = result * 0x100000B1721BCFC99D9F890EA06911763 >> 128;
      if (x & 0x80000000000 > 0)
        result = result * 0x10000058B90CF1E6D97F9CA14DBCC1628 >> 128;
      if (x & 0x40000000000 > 0)
        result = result * 0x1000002C5C863B73F016468F6BAC5CA2B >> 128;
      if (x & 0x20000000000 > 0)
        result = result * 0x100000162E430E5A18F6119E3C02282A5 >> 128;
      if (x & 0x10000000000 > 0)
        result = result * 0x1000000B1721835514B86E6D96EFD1BFE >> 128;
      if (x & 0x8000000000 > 0)
        result = result * 0x100000058B90C0B48C6BE5DF846C5B2EF >> 128;
      if (x & 0x4000000000 > 0)
        result = result * 0x10000002C5C8601CC6B9E94213C72737A >> 128;
      if (x & 0x2000000000 > 0)
        result = result * 0x1000000162E42FFF037DF38AA2B219F06 >> 128;
      if (x & 0x1000000000 > 0)
        result = result * 0x10000000B17217FBA9C739AA5819F44F9 >> 128;
      if (x & 0x800000000 > 0)
        result = result * 0x1000000058B90BFCDEE5ACD3C1CEDC823 >> 128;
      if (x & 0x400000000 > 0)
        result = result * 0x100000002C5C85FE31F35A6A30DA1BE50 >> 128;
      if (x & 0x200000000 > 0)
        result = result * 0x10000000162E42FF0999CE3541B9FFFCF >> 128;
      if (x & 0x100000000 > 0)
        result = result * 0x100000000B17217F80F4EF5AADDA45554 >> 128;
      if (x & 0x80000000 > 0)
        result = result * 0x10000000058B90BFBF8479BD5A81B51AD >> 128;
      if (x & 0x40000000 > 0)
        result = result * 0x1000000002C5C85FDF84BD62AE30A74CC >> 128;
      if (x & 0x20000000 > 0)
        result = result * 0x100000000162E42FEFB2FED257559BDAA >> 128;
      if (x & 0x10000000 > 0)
        result = result * 0x1000000000B17217F7D5A7716BBA4A9AE >> 128;
      if (x & 0x8000000 > 0)
        result = result * 0x100000000058B90BFBE9DDBAC5E109CCE >> 128;
      if (x & 0x4000000 > 0)
        result = result * 0x10000000002C5C85FDF4B15DE6F17EB0D >> 128;
      if (x & 0x2000000 > 0)
        result = result * 0x1000000000162E42FEFA494F1478FDE05 >> 128;
      if (x & 0x1000000 > 0)
        result = result * 0x10000000000B17217F7D20CF927C8E94C >> 128;
      if (x & 0x800000 > 0)
        result = result * 0x1000000000058B90BFBE8F71CB4E4B33D >> 128;
      if (x & 0x400000 > 0)
        result = result * 0x100000000002C5C85FDF477B662B26945 >> 128;
      if (x & 0x200000 > 0)
        result = result * 0x10000000000162E42FEFA3AE53369388C >> 128;
      if (x & 0x100000 > 0)
        result = result * 0x100000000000B17217F7D1D351A389D40 >> 128;
      if (x & 0x80000 > 0)
        result = result * 0x10000000000058B90BFBE8E8B2D3D4EDE >> 128;
      if (x & 0x40000 > 0)
        result = result * 0x1000000000002C5C85FDF4741BEA6E77E >> 128;
      if (x & 0x20000 > 0)
        result = result * 0x100000000000162E42FEFA39FE95583C2 >> 128;
      if (x & 0x10000 > 0)
        result = result * 0x1000000000000B17217F7D1CFB72B45E1 >> 128;
      if (x & 0x8000 > 0)
        result = result * 0x100000000000058B90BFBE8E7CC35C3F0 >> 128;
      if (x & 0x4000 > 0)
        result = result * 0x10000000000002C5C85FDF473E242EA38 >> 128;
      if (x & 0x2000 > 0)
        result = result * 0x1000000000000162E42FEFA39F02B772C >> 128;
      if (x & 0x1000 > 0)
        result = result * 0x10000000000000B17217F7D1CF7D83C1A >> 128;
      if (x & 0x800 > 0)
        result = result * 0x1000000000000058B90BFBE8E7BDCBE2E >> 128;
      if (x & 0x400 > 0)
        result = result * 0x100000000000002C5C85FDF473DEA871F >> 128;
      if (x & 0x200 > 0)
        result = result * 0x10000000000000162E42FEFA39EF44D91 >> 128;
      if (x & 0x100 > 0)
        result = result * 0x100000000000000B17217F7D1CF79E949 >> 128;
      if (x & 0x80 > 0)
        result = result * 0x10000000000000058B90BFBE8E7BCE544 >> 128;
      if (x & 0x40 > 0)
        result = result * 0x1000000000000002C5C85FDF473DE6ECA >> 128;
      if (x & 0x20 > 0)
        result = result * 0x100000000000000162E42FEFA39EF366F >> 128;
      if (x & 0x10 > 0)
        result = result * 0x1000000000000000B17217F7D1CF79AFA >> 128;
      if (x & 0x8 > 0)
        result = result * 0x100000000000000058B90BFBE8E7BCD6D >> 128;
      if (x & 0x4 > 0)
        result = result * 0x10000000000000002C5C85FDF473DE6B2 >> 128;
      if (x & 0x2 > 0)
        result = result * 0x1000000000000000162E42FEFA39EF358 >> 128;
      if (x & 0x1 > 0)
        result = result * 0x10000000000000000B17217F7D1CF79AB >> 128;

      result >>= uint256 (int256 (63 - (x >> 64)));
      require (result <= uint256 (int256 (MAX_64x64)));

      return int128 (int256 (result));
    }
  }

  /**
   * Calculate natural exponent of x.  Revert on overflow.
   *
   * @param x signed 64.64-bit fixed point number
   * @return signed 64.64-bit fixed point number
   */
  function exp (int128 x) internal pure returns (int128) {
    unchecked {
      require (x < 0x400000000000000000); // Overflow

      if (x < -0x400000000000000000) return 0; // Underflow

      return exp_2 (
          int128 (int256 (x) * 0x171547652B82FE1777D0FFDA0D23A7D12 >> 128));
    }
  }

  /**
   * Calculate x / y rounding towards zero, where x and y are unsigned 256-bit
   * integer numbers.  Revert on overflow or when y is zero.
   *
   * @param x unsigned 256-bit integer number
   * @param y unsigned 256-bit integer number
   * @return unsigned 64.64-bit fixed point number
   */
  function divuu (uint256 x, uint256 y) private pure returns (uint128) {
    unchecked {
      require (y != 0);

      uint256 result;

      if (x <= 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)
        result = (x << 64) / y;
      else {
        uint256 msb = 192;
        uint256 xc = x >> 192;
        if (xc >= 0x100000000) { xc >>= 32; msb += 32; }
        if (xc >= 0x10000) { xc >>= 16; msb += 16; }
        if (xc >= 0x100) { xc >>= 8; msb += 8; }
        if (xc >= 0x10) { xc >>= 4; msb += 4; }
        if (xc >= 0x4) { xc >>= 2; msb += 2; }
        if (xc >= 0x2) msb += 1;  // No need to shift xc anymore

        result = (x << 255 - msb) / ((y - 1 >> msb - 191) + 1);
        require (result <= 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);

        uint256 hi = result * (y >> 128);
        uint256 lo = result * (y & 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);

        uint256 xh = x >> 192;
        uint256 xl = x << 64;

        if (xl < lo) xh -= 1;
        xl -= lo; // We rely on overflow behavior here
        lo = hi << 128;
        if (xl < lo) xh -= 1;
        xl -= lo; // We rely on overflow behavior here

        result += xh == hi >> 128 ? xl / y : 1;
      }

      require (result <= 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);
      return uint128 (result);
    }
  }

  /**
   * Calculate sqrt (x) rounding down, where x is unsigned 256-bit integer
   * number.
   *
   * @param x unsigned 256-bit integer number
   * @return unsigned 128-bit integer number
   */
  function sqrtu (uint256 x) private pure returns (uint128) {
    unchecked {
      if (x == 0) return 0;
      else {
        uint256 xx = x;
        uint256 r = 1;
        if (xx >= 0x100000000000000000000000000000000) { xx >>= 128; r <<= 64; }
        if (xx >= 0x10000000000000000) { xx >>= 64; r <<= 32; }
        if (xx >= 0x100000000) { xx >>= 32; r <<= 16; }
        if (xx >= 0x10000) { xx >>= 16; r <<= 8; }
        if (xx >= 0x100) { xx >>= 8; r <<= 4; }
        if (xx >= 0x10) { xx >>= 4; r <<= 2; }
        if (xx >= 0x4) { r <<= 1; }
        r = (r + x / r) >> 1;
        r = (r + x / r) >> 1;
        r = (r + x / r) >> 1;
        r = (r + x / r) >> 1;
        r = (r + x / r) >> 1;
        r = (r + x / r) >> 1;
        r = (r + x / r) >> 1; // Seven iterations should be enough
        uint256 r1 = x / r;
        return uint128 (r < r1 ? r : r1);
      }
    }
  }
}