The SuperNode precompile

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

/// @notice Precompile at 0x0000000000000000000000000000000000000902
interface ISupernode {
    /// @notice On-chain information about a registered SuperNode.
    struct SuperNodeInfo {
        string validatorAddress;   // Bech32 lumeravaloper... address
        string supernodeAccount;   // Bech32 lumera... account address
        uint8 currentState;        // see the state table above
        int64 stateHeight;         // block height of last state transition
        string ipAddress;          // current IP address
        string p2pPort;            // P2P listening port
        string note;               // operator-set note
        uint64 evidenceCount;      // number of misbehavior evidence records
    }

    /// @notice Hardware metrics reported by a SuperNode.
    struct MetricsReport {
        uint32 versionMajor;
        uint32 versionMinor;
        uint32 versionPatch;
        uint32 cpuCoresTotal;
        uint64 cpuUsagePercent;
        uint64 memTotalGb;
        uint64 memUsagePercent;
        uint64 memFreeGb;
        uint64 diskTotalGb;
        uint64 diskUsagePercent;
        uint64 diskFreeGb;
        uint64 uptimeSeconds;
        uint32 peersCount;
    }

    /// @notice Get SuperNode info by validator address.
    function getSuperNode(
        string calldata validatorAddress
    ) external view returns (SuperNodeInfo memory info);

    /// @notice Get SuperNode info by its operator account address.
    function getSuperNodeByAccount(
        string calldata supernodeAddress
    ) external view returns (SuperNodeInfo memory info);

    /// @notice List all registered SuperNodes with pagination.
    /// @param limit Max results to return (capped at 100)
    function listSuperNodes(
        uint64 offset,
        uint64 limit
    ) external view returns (SuperNodeInfo[] memory nodes, uint64 total);

    /// @notice Get top SuperNodes for a block by XOR-distance ranking.
    /// @param state Filter by state (0 = all states)
    function getTopSuperNodesForBlock(
        int32 blockHeight,
        int32 limit,
        uint8 state
    ) external view returns (SuperNodeInfo[] memory nodes);

    /// @notice Get the latest metrics for a SuperNode.
    function getMetrics(
        string calldata validatorAddress
    ) external view returns (
        MetricsReport memory metrics,
        uint64 reportCount,
        int64 lastReportHeight
    );

    /// @notice Get the SuperNode module parameters.
    function getParams() external view returns (
        uint256 minimumStake,
        uint64 reportingThreshold,
        uint64 slashingThreshold,
        string memory minSupernodeVersion,
        uint64 minCpuCores,
        uint64 minMemGb,
        uint64 minStorageGb
    );
}

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

import "./ISupernode.sol";

contract SupernodeDashboard {
    ISupernode constant SN = ISupernode(0x0000000000000000000000000000000000000902);

    /// @notice Total number of registered SuperNodes.
    function totalSupernodes() external view returns (uint64) {
        (, uint64 total) = SN.listSuperNodes(0, 1);
        return total;
    }

    /// @notice Top N active SuperNodes for a given block.
    function topForBlock(int32 blockHeight, int32 count)
        external view returns (ISupernode.SuperNodeInfo[] memory)
    {
        return SN.getTopSuperNodesForBlock(blockHeight, count, 1); // 1 = Active
    }

    /// @notice Whether a SuperNode has ever reported metrics.
    function isHealthy(string calldata validatorAddress)
        external view returns (bool hasReported, uint64 reportCount)
    {
        (, reportCount, ) = SN.getMetrics(validatorAddress);
        hasReported = reportCount > 0;
    }

    /// @notice Minimum stake required to register.
    function minimumStake() external view returns (uint256) {
        (uint256 stake, , , , , , ) = SN.getParams();
        return stake;
    }
}

import { ethers } from "ethers";

const SN_ADDRESS = "0x0000000000000000000000000000000000000902";

const SN_ABI = [
  "function getParams() view returns (uint256 minimumStake, uint64 reportingThreshold, uint64 slashingThreshold, string minSupernodeVersion, uint64 minCpuCores, uint64 minMemGb, uint64 minStorageGb)",
  "function listSuperNodes(uint64 offset, uint64 limit) view returns (tuple(string validatorAddress, string supernodeAccount, uint8 currentState, int64 stateHeight, string ipAddress, string p2pPort, string note, uint64 evidenceCount)[], uint64 total)",
];

// Point at your node's EVM JSON-RPC endpoint (port 8545)
const provider = new ethers.JsonRpcProvider("http://localhost:8545");
const supernode = new ethers.Contract(SN_ADDRESS, SN_ABI, provider);

const params = await supernode.getParams();
console.log(`Min stake: ${params.minimumStake} ulume`);
console.log(`Min version: ${params.minSupernodeVersion}`);

const [nodes, total] = await supernode.listSuperNodes(0n, 10n);
console.log(`Total SuperNodes: ${total}`);
for (const node of nodes) {
  console.log(`${node.validatorAddress} state=${node.currentState}`);
}