简单的Owner合约

1、实现 Owner合约
2、新Owner depending合约

// 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);
}
}