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

contract QuantumLynxProofOfPower {

    struct Validator {
        address validatorAddress;
        uint256 power; // Quantum power metric
    }

    mapping(address => Validator) public validators;
    address[] public validatorList;

    address public owner;
    uint256 public totalPower;

    event ValidatorAdded(address indexed validatorAddress, uint256 power);
    event ValidatorPowerUpdated(address indexed validatorAddress, uint256 newPower);
    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
    event TransactionVerified(address indexed validator, uint256 power);

    modifier onlyOwner() {
        require(msg.sender == owner, "Caller is not the owner");
        _;
    }

    constructor() {
        owner = msg.sender;
    }

    // Function to transfer ownership
    function transferOwnership(address newOwner) public onlyOwner {
        require(newOwner != address(0), "New owner is the zero address");
        emit OwnershipTransferred(owner, newOwner);
        owner = newOwner;
    }

    // Function to add a new validator
    function addValidator(address _validatorAddress, uint256 _power) public onlyOwner {
        require(_validatorAddress != address(0), "Invalid address");
        require(validators[_validatorAddress].validatorAddress == address(0), "Validator already exists");

        validators[_validatorAddress] = Validator(_validatorAddress, _power);
        validatorList.push(_validatorAddress);
        totalPower += _power;

        emit ValidatorAdded(_validatorAddress, _power);
    }

    // Function to update the power of an existing validator
    function updateValidatorPower(address _validatorAddress, uint256 _newPower) public onlyOwner {
        require(validators[_validatorAddress].validatorAddress != address(0), "Validator does not exist");

        totalPower -= validators[_validatorAddress].power;  // Subtract old power
        totalPower += _newPower;  // Add new power

        validators[_validatorAddress].power = _newPower;

        emit ValidatorPowerUpdated(_validatorAddress, _newPower);
    }

    // Function to calculate the Proof of Power
    function calculateProofOfPower(address _validatorAddress) public view returns (uint256) {
        require(validators[_validatorAddress].validatorAddress != address(0), "Validator does not exist");

        uint256 validatorPower = validators[_validatorAddress].power;
        return (validatorPower * 100) / totalPower;  // Percentage of total power
    }

    // Function to verify a transaction
    function verifyTransaction(address _validatorAddress) public {
        uint256 validatorPoP = calculateProofOfPower(_validatorAddress);
        require(validatorPoP > 0, "Validator has no power");

        emit TransactionVerified(_validatorAddress, validatorPoP);
    }
}