Propiedad con Ownable

Revisando la librería, veo que al renunciar al owner lo que pasa es que se transfiere el owner del contrato a la dirección ‘0’, por lo que entiendo que en Solidity no se puede quedar un contrato sin owner, simplemente se le asigna a 0 para que ninguna dirección sea la dueña.

Es interesante porque a partir de ahí, sería imposible reasignar el owner si no se llama a la función desde la dirección “0”, elegante y sencillo.

Esas funciones para renunciar al owner se podrían usar por ejemplo si tenemos ciertos pasos previos a empezar la operación del contrato?

Digamos que hay una función que asigna tokens manualmente de acuerdo a un nivel de usuario, esto en una ICO o similar, una vez que terminó esa etapa se podría dejar al contrato trabajando en automático y para darle transparencia al asunto, inutilizar esa función de asignación manual renunciando al owner, de este modo el contrato trabajaría solo de acuerdo a las reglas programadas.

Es algo así o podría ser?

Éste es el contrato Ownable

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (access/Ownable.sol)

pragma solidity ^0.8.0;

import "../utils/Context.sol";

/**
 * @dev Contract module which provides a basic access control mechanism, where
 * there is an account (an owner) that can be granted exclusive access to
 * specific functions.
 *
 * By default, the owner account will be the one that deploys the contract. This
 * can later be changed with {transferOwnership}.
 *
 * This module is used through inheritance. It will make available the modifier
 * `onlyOwner`, which can be applied to your functions to restrict their use to
 * the owner.
 */
abstract contract Ownable is Context {
    address private _owner;

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

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    constructor() {
        _transferOwnership(_msgSender());
    }

    /**
     * @dev Returns the address of the current owner.
     */
    function owner() public view virtual returns (address) {
        return _owner;
    }

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        require(owner() == _msgSender(), "Ownable: caller is not the owner");
        _;
    }

    /**
     * @dev Leaves the contract without owner. It will not be possible to call
     * `onlyOwner` functions anymore. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby removing any functionality that is only available to the owner.
     */
    function renounceOwnership() public virtual onlyOwner {
        _transferOwnership(address(0));
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public virtual onlyOwner {
        require(newOwner != address(0), "Ownable: new owner is the zero address");
        _transferOwnership(newOwner);
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Internal function without access restriction.
     */
    function _transferOwnership(address newOwner) internal virtual {
        address oldOwner = _owner;
        _owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }
}

Aunque peligroso el método que permite renunciar al contrato se puede utilizar como mecanismo de seguridad para dejar un contrato obsoleto, algo así como quemar el contrato si se sospecha que la cuenta del dueño del contrato fue robada.
¿También me pregunto qué otros usos o bajo qué circunstancias alguien quisiera renunciar a sus permisos dentro del contrato?
Igual que terrible si alguien accede a tu cuenta y renuncia a los permisos solo por hacerte daño…