SuperNodeRegistry

{{
  "language": "Solidity",
  "sources": {
    "contracts/SuperNodeRegistry.sol": {
      "content": "// SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;

/**
 * @title SuperNode Registry
 * @notice Records all SuperNode wallet registrations under chronara.eth
 * @dev Linked to chronara.eth ENS name for decentralized management
 */
contract SuperNodeRegistry {
    // ========== STATE VARIABLES ==========

    /// @notice Address of the contract owner (chronara.eth)
    address public owner;

    /// @notice Address of the required NFT contract for verification
    address public nftContract;

    /// @notice Total number of registered SuperNodes
    uint256 public totalRegistered;

    /// @notice Mapping of wallet address to registration data
    mapping(address => SuperNodeData) public superNodes;

    /// @notice Array of all registered wallet addresses
    address[] public registeredWallets;

    // ========== STRUCTS ==========

    struct SuperNodeData {
        bool isRegistered;
        uint256 registrationTimestamp;
        uint256 lastActivityTimestamp;
        uint256 nftBalance;
        string walletProvider; // "MetaMask", "Trust Wallet", "WalletConnect", etc.
    }

    // ========== EVENTS ==========

    event SuperNodeRegistered(
        address indexed wallet,
        uint256 timestamp,
        uint256 nftBalance,
        string walletProvider
    );

    event SuperNodeActivityUpdated(
        address indexed wallet,
        uint256 timestamp
    );

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

    event NFTContractUpdated(
        address indexed previousContract,
        address indexed newContract
    );

    // ========== MODIFIERS ==========

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

    modifier notRegistered() {
        require(!superNodes[msg.sender].isRegistered, "Already registered");
        _;
    }

    // ========== CONSTRUCTOR ==========

    /**
     * @notice Initialize the SuperNode Registry
     * @param _nftContract Address of the required NFT contract
     */
    constructor(address _nftContract) {
        owner = msg.sender;
        nftContract = _nftContract;
        totalRegistered = 0;
    }

    // ========== PUBLIC FUNCTIONS ==========

    /**
     * @notice Register a SuperNode wallet
     * @param _nftBalance NFT balance of the wallet
     * @param _walletProvider Name of the wallet provider used
     */
    function registerSuperNode(
        uint256 _nftBalance,
        string memory _walletProvider
    ) external notRegistered {
        require(_nftBalance > 0, "Must hold at least 1 NFT");

        // Create registration data
        superNodes[msg.sender] = SuperNodeData({
            isRegistered: true,
            registrationTimestamp: block.timestamp,
            lastActivityTimestamp: block.timestamp,
            nftBalance: _nftBalance,
            walletProvider: _walletProvider
        });

        // Add to registered wallets array
        registeredWallets.push(msg.sender);
        totalRegistered++;

        emit SuperNodeRegistered(
            msg.sender,
            block.timestamp,
            _nftBalance,
            _walletProvider
        );
    }

    /**
     * @notice Update activity timestamp for a SuperNode
     * @dev Called when a SuperNode accesses the platform
     */
    function updateActivity() external {
        require(superNodes[msg.sender].isRegistered, "Not registered");

        superNodes[msg.sender].lastActivityTimestamp = block.timestamp;

        emit SuperNodeActivityUpdated(msg.sender, block.timestamp);
    }

    /**
     * @notice Update NFT balance for a SuperNode
     * @param _newBalance New NFT balance
     */
    function updateNFTBalance(uint256 _newBalance) external {
        require(superNodes[msg.sender].isRegistered, "Not registered");

        superNodes[msg.sender].nftBalance = _newBalance;
        superNodes[msg.sender].lastActivityTimestamp = block.timestamp;
    }

    // ========== VIEW FUNCTIONS ==========

    /**
     * @notice Check if a wallet is registered
     * @param _wallet Address to check
     * @return bool Registration status
     */
    function isRegistered(address _wallet) external view returns (bool) {
        return superNodes[_wallet].isRegistered;
    }

    /**
     * @notice Get SuperNode data for a wallet
     * @param _wallet Address to query
     * @return SuperNodeData struct
     */
    function getSuperNodeData(address _wallet)
        external
        view
        returns (SuperNodeData memory)
    {
        return superNodes[_wallet];
    }

    /**
     * @notice Get all registered wallet addresses
     * @return address[] Array of registered wallets
     */
    function getAllRegisteredWallets() external view returns (address[] memory) {
        return registeredWallets;
    }

    /**
     * @notice Get registration info for a wallet
     * @param _wallet Address to query
     * @return registered Registration status
     * @return registrationTimestamp Registration timestamp
     * @return lastActivityTimestamp Last activity timestamp
     * @return nftBalance NFT balance
     * @return walletProvider Wallet provider name
     */
    function getRegistrationInfo(address _wallet)
        external
        view
        returns (
            bool registered,
            uint256 registrationTimestamp,
            uint256 lastActivityTimestamp,
            uint256 nftBalance,
            string memory walletProvider
        )
    {
        SuperNodeData memory data = superNodes[_wallet];
        return (
            data.isRegistered,
            data.registrationTimestamp,
            data.lastActivityTimestamp,
            data.nftBalance,
            data.walletProvider
        );
    }

    // ========== ADMIN FUNCTIONS ==========

    /**
     * @notice Transfer ownership to chronara.eth ENS address
     * @param _newOwner New owner address (should be chronara.eth)
     */
    function transferOwnership(address _newOwner) external onlyOwner {
        require(_newOwner != address(0), "Invalid address");

        address previousOwner = owner;
        owner = _newOwner;

        emit OwnershipTransferred(previousOwner, _newOwner);
    }

    /**
     * @notice Update the NFT contract address
     * @param _newContract New NFT contract address
     */
    function updateNFTContract(address _newContract) external onlyOwner {
        require(_newContract != address(0), "Invalid address");

        address previousContract = nftContract;
        nftContract = _newContract;

        emit NFTContractUpdated(previousContract, _newContract);
    }

    /**
     * @notice Emergency function to remove a registration (admin only)
     * @param _wallet Wallet address to remove
     */
    function removeRegistration(address _wallet) external onlyOwner {
        require(superNodes[_wallet].isRegistered, "Not registered");

        superNodes[_wallet].isRegistered = false;
        totalRegistered--;

        // Note: We keep the wallet in registeredWallets array for historical records
        // but mark it as not registered in the mapping
    }
}
"
    }
  },
  "settings": {
    "optimizer": {
      "enabled": true,
      "runs": 200
    },
    "outputSelection": {
      "*": {
        "*": [
          "evm.bytecode",
          "evm.deployedBytecode",
          "devdoc",
          "userdoc",
          "metadata",
          "abi"
        ]
      }
    }
  }
}}