Creación de contratos de propiedad en Solidity

Un contrato inteligente (o contrato criptográfico) es un programa informático que controla directa y automáticamente la transferencia de activos digitales entre las partes bajo ciertas condiciones. Una vez implementado, un código de contrato inteligente no se puede cambiar. También es públicamente visible para todos. 
Solidity es un lenguaje utilizado para crear contratos inteligentes que luego se compila en un código de bytes que a su vez se implementa en la red Ethereum . Aunque el código es visible públicamente, la llamada de funciones se puede restringir mediante modificadores.
Solidity proporciona algunos modificadores de acceso por defecto:

1. Público- Accesible por cualquier persona
2. Privado: accesible solo por contratos donde se definen y no por contratos heredados.
3. Protegido- Accesible solo por los contratos donde se definen y por los contratos que los heredan.
4. Interno- Accesible solo por otras funciones del contrato y no por otras personas o contratos.
5. Externo- Accesible solo por otras personas o contratos y no por funciones.

Necesidad de contratos de propiedad:
algunas funciones son necesarias solo con fines de configuración o cálculos únicos. Tales funciones, si se exponen públicamente, pueden usarse de forma malintencionada o errónea para agotar los gases. Para evitar el uso indebido o reducir el costo del gas, tales funciones deben restringirse solo a direcciones externas seleccionadas (por simplicidad, propietario). Para solucionar esto, se pueden utilizar contratos de propiedad.
A continuación se muestra el código para un contrato de propiedad. Puede ser heredado por otros contratos que pretendan tener modificadores propios para funciones seleccionadas.
A continuación se muestra el programa Solidity para el enfoque anterior:

// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.7.0;
  
contract Ownable 
{    
  // Variable that maintains 
  // owner address
  address private _owner;
  
  // Sets the original owner of 
  // contract when it is deployed
  constructor()
  {
    _owner = msg.sender;
  }
  
  // Publicly exposes who is the
  // owner of this contract
  function owner() public view returns(address) 
  {
    return _owner;
  }
  
  // onlyOwner modifier that validates only 
  // if caller of function is contract owner, 
  // otherwise not
  modifier onlyOwner() 
  {
    require(isOwner(),
    "Function accessible only by the owner !!");
    _;
  }
  
  // function for owners to verify their ownership. 
  // Returns true for owners otherwise false
  function isOwner() public view returns(bool) 
  {
    return msg.sender == _owner;
  }
}
  
contract OwnableDemo is Ownable 
{ 
    uint sum = 0;
    uint[] numbers;
  
    // Push number to array
    function addNumber(uint number) public
    {
        numbers.push(number);
    }
  
    // Read sum variable
    function getSum() public view returns(uint)
    {
        return sum;
    }
  
    /* 
        Calculate sum by traversing array
        The onlyOwner modifier used here prevents 
        this function to be called by people other 
        than owner who deployed it
    */
    function calculateSum() onlyOwner public
    {
        sum = 0;
        for(uint i = 0;  
                 i < numbers.length; i++)
            sum += numbers[i];
    }
}

Salida:
agregar números desde cualquier dirección (propietario o no, no importa): 
la función se llamó tres veces con argumentos: 5, 6 y 2 respectivamente

Intento de llamar a computeSum() desde una dirección que no es del propietario (sin éxito):

Llamando a computeSum() como propietario (Exitoso):