Simple Owner contract

1. Realize the Owner contract
2. New Owner depending contract

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

abstract contract context{
    
    

function _msgSender() internal view virtual returns (address){
    
    
return msg.sender;
}

function _masData() internal view virtual returns (bytes calldata){
    
    
return msg.data;
}

}


contract Ownable is context{
    
    
    address payable public owner;
    mapping(address => uint) public shares;
    constructor(){
    
    
        _transOwner(_msgSender());
    }
    modifier onlyOwner{
    
    
        require(owner == _msgSender(),"not the owner");
        _;

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

    function _transOwner(address newOwner) internal virtual{
    
    
    address oldOwner = owner;
    owner = payable(newOwner);
    emit OwnershipTransferred(oldOwner,owner);
    }

    function  transOwner(address newOwner) public virtual onlyOwner{
    
    
        require (newOwner!=address(0),"new address is zero");
        _transOwner(newOwner);
    }

    function reannounceOwner() public virtual onlyOwner{
    
    
    _transOwner(address(0));
    }

    function Owner() public view virtual returns (address) {
    
    
        return owner;
    }

    function withdraw(uint _amount) onlyOwner public{
    
     
     //   require(shares[msg.sender] >= _amount,"not enough balance");
        shares[msg.sender] -= _amount;
        payable(msg.sender).transfer(_amount);
    }

    function exposit(uint amount) public{
    
    
    shares[msg.sender]=amount;
    }

    function getBalance() public returns(uint bal) {
    
    
     bal =shares[msg.sender];
     return bal;
    }
}

contract OwnablePending is Ownable{
    
    
    event OwnerTranferred(address indexed oldaddress, address indexed newaddress);
    address private dependingOwner;

function transOwner (address newOwner) public virtual onlyOwner override{
    
    
    dependingOwner=newOwner;
    emit OwnerTranferred(Owner(),dependingOwner);

}

function _transOwner(address newOwner) internal virtual override{
    
     
delete dependingOwner;
super._transOwner(newOwner);
}

function accept()public virtual{
    
    
    address sender = _msgSender();
    require(sender == dependingOwner);
    _transOwner(sender);
}
}