// Validator signing information for liveness monitoring
struct SigningInfo {
    address validatorAddress;       // Validator operator address
    int64 startHeight;             // Height at which validator was first a candidate or was unjailed
    int64 indexOffset;             // Index offset into signed block bit array
    int64 jailedUntil;             // Timestamp until which validator is jailed
    bool tombstoned;               // Whether validator has been permanently removed
    int64 missedBlocksCounter;     // Count of missed blocks
}

// Slashing module parameters
struct Params {
    int64 signedBlocksWindow;      // Number of blocks to track for signing
    Dec minSignedPerWindow;        // Minimum percentage of blocks to sign
    int64 downtimeJailDuration;    // Duration of jail time for downtime
    Dec slashFractionDoubleSign;   // Slash percentage for double signing
    Dec slashFractionDowntime;     // Slash percentage for downtime
}

// Decimal type representation
struct Dec {
    string value;  // Decimal string representation
}

// Unjail a validator after downtime slashing
function unjail(address validatorAddress) external returns (bool success);

// Get signing info for a specific validator
function getSigningInfo(
    address consAddress
) external view returns (SigningInfo memory signingInfo);

// Get signing info for all validators with pagination
function getSigningInfos(
    PageRequest calldata pagination
) external view returns (
    SigningInfo[] memory signingInfos,
    PageResponse memory pageResponse
);

// Get slashing module parameters
function getParams() external view returns (Params memory params);

event ValidatorUnjailed(address indexed validator);

ISlashing slashing = ISlashing(SLASHING_PRECOMPILE_ADDRESS);

// Query validator signing info
address consAddress = 0x...; // Validator consensus address
SigningInfo memory info = slashing.getSigningInfo(consAddress);

// Check if validator is jailed
if (info.jailedUntil > int64(block.timestamp)) {
    // Validator is currently jailed

    // If jail period has expired and caller is the validator
    if (block.timestamp >= uint64(info.jailedUntil)) {
        // Unjail the validator
        bool success = slashing.unjail(msg.sender);
        require(success, "Failed to unjail");
    }
}

// Query slashing parameters
Params memory params = slashing.getParams();
// Access parameters like params.signedBlocksWindow

contract ValidatorManager {
    ISlashing constant slashing = ISlashing(SLASHING_PRECOMPILE_ADDRESS);

    function checkValidatorStatus(address validatorAddr) public view returns (
        bool isJailed,
        int64 jailedUntil,
        bool canUnjail
    ) {
        // Convert to consensus address (implementation specific)
        address consAddr = getConsensusAddress(validatorAddr);

        SigningInfo memory info = slashing.getSigningInfo(consAddr);

        isJailed = info.jailedUntil > int64(block.timestamp);
        jailedUntil = info.jailedUntil;
        canUnjail = isJailed && block.timestamp >= uint64(info.jailedUntil) && !info.tombstoned;
    }

    function autoUnjail(address validatorAddr) external {
        (, , bool canUnjail) = checkValidatorStatus(validatorAddr);
        require(canUnjail, "Cannot unjail yet");
        require(msg.sender == validatorAddr, "Only validator can unjail");

        slashing.unjail(validatorAddr);
    }
}