Inheritance Assignment

Ethereum Smart Contract Programming 101
#812 
pragma solidity 0.7.5;

contract Destroyable{
    address payable owner;
    
    constructor(){
        owner = msg.sender;
    }
    
    modifier onlyOwner(){
        require(msg.sender == owner);
        _;
    }
    
    function destroy() internal onlyOwner{
        selfdestruct(owner);
    }
}
1 Like
#813

Hey @William

Seems like you have imported Destroyable both in BankContract and Ownable.
Because BankContract imports Ownable it is like you are importing Destroyable twice.
If Ownable imports Destroyable, your bank should only import Ownable.

Cheers,
Dani

#814

//SPDX-License-Identifier: GPL-3.0
//this is file destroyable.sol
pragma solidity ^0.7.5;

contract destroyable{

address payable owner;

constructor(){
    owner = msg.sender;
}
modifier only_Owner{
    require(msg.sender == owner);
    _;
}
function destroy_contract() internal only_owner{
    selfdestruct(owner);
}

}
//------------------------------------------
//SPDX-License-Identifier: GPL-3.0
//file inherits_destroyable.sol
pragma solidity ^0.7.5;
import “./destroyable.sol”;

contract waiting_to_be_destroyed is destroyable{
function summon_the_end() public{ //can this function return anything if the result will be destruction?
destroy_contract();
}
}

1 Like
#815

pragma solidity 0.7.5;

contract Ownable {
address public owner;

modifier onlyOwner {
    require(msg.sender == owner);
    _; // means run the function
}
constructor (){
    owner = msg.sender;
 }

}

pragma solidity 0.7.5;

import “./Ownable.sol”;

contract Destroyable is Ownable{

function close() public onlyOwner { //onlyOwner is custom modifier
    selfdestruct(msg.sender);  // `owner` is the owners address

}
}

1 Like
#816

Im a bit confused with the solution of the Destroyable.

in this function:

function destroy() public onlyOwner {
    address payable receiver = msg.sender;
    selfdestruct(receiver);
  }

why we cant use the state variable owner declared in te contract Ownable?

#817

Hey @zero0_cero

If your contract imports Ownable and if the variable owner is public or internal you can use it in your function destroy. Keep in mind that selfdestruct wants a payable address as parameter.

Cheers,
Dani

#818

thats what I was suposed but when using the owner variable in the selfdestruct, I get an error
“Invalid type for argument in function call. Invalid implicit conversion from address to address payable requested”

this is my code:

pragma solidity 0.7.5;

contract Ownable {
    
    address internal owner;
    
    modifier onlyOwner {
        require(msg.sender == owner);
        _;
    }
    
    constructor (){
        owner = msg.sender;
    }
}

pragma solidity 0.7.5;

import "./ownable.sol";
import "./Destructor.sol";

contract Destroyable is Ownable,Destructor {
    
    uint value;
    
    function setValue(uint _value) public {
        
        value = _value;
    }
    
    function getValue() public view returns(uint){
        
        return value;
    }
}

pragma solidity 0.7.5;


import "./ownable.sol";

contract Destructor is Ownable {
    
    function wipeOut() public onlyOwner {
        
       //address payable _owner = msg.sender;
        
        selfdestruct(owner); 
    }
}

it is something wrong there?

#819

Hey @zero0_cero

The issue is that you are not passing a payable address to selfdistruct.

  function wipeOut() public onlyOwner {
        
       //address payable _owner = msg.sender;
        
        selfdestruct(owner); 
    }

You can:

selfdestruct(payable(msg.sender));

or

        address payable _owner = msg.sender;
        
        selfdestruct(_owner);

Cheers,
Dani

#820

Im doing it in the constructor in the contract Ownable.

constructor (){
        owner = msg.sender;
    }

Here the state variable is equal to msg.sender…
I have some missunderstanding i guess.
Why this doesnt work?

#821

Whatever variable you are using, you just need to cast it to payable.
If you want to use owner do payable(owner) when you call selfdestruct and will work :slight_smile:

#822

ok.
So I have to cast it again to payable, right?

#823 
pragma solidity 0.7.5;

contract  Destroyable {
    
    address payable internal owner;

    constructor(){
        owner = msg.sender;
    }    
    modifier onlyOwner{
        require(msg.sender == owner);
        _;
    }
    
    function nukeItBaby() public onlyOwner {
        selfdestruct(owner);
    }

}

@filip I wrote the code before looking at the pushed solution, thus I put everything in the Destroyable contract. I would like to ask a couple of things:

  1. Does it makes sense to user the internal modifier for the owner variable?
  2. I tried to invoke the function in Remix after deploying, but the contract was not deleted, like pressing the trash bin button. Is there something wrong with the implementation or is this behavior normal?
    Thanks!
#824 
pragma solidity 0.7.5;

contract Ownable {
    
   address public owner; 
   
   modifier onlyOwner(){
       require(msg.sender == owner);
       _;
   }
     
   constructor() public {
       owner = msg.sender;
   }
}

contract Destroyable is Ownable {
     
        function destroy() public onlyOwner {
        selfdestruct(owner);
    }
}
#825

This is my Destroyable Contract:

import "./Ownable.sol";

contract Destroyable is Ownable {
    function endIt() public onlyOwner {
        address payable owner;
        owner = msg.sender;
        selfdestruct(owner);
    }
}

This is how I implemented it into the Bank Contract:


import "./Ownable.sol";
import "./Destroyable.sol";

contract Bank is Ownable, Destroyable {
#826

I just realized it would have been easier to implement this function in the same contract as Ownable

#827

Destroyable.sol

pragma solidity 0.7.5;
import "./Ownable.sol";

contract Destroyable is Ownable{
    function removeContract() public onlyOwner {
        selfdestruct(owner);
    }
}

Bank.sol

pragma solidity 0.7.5;
import "./Destroyable.sol";
import "./Ownable.sol";

contract Bank is Ownable, Destroyable{
#828

Hi @zero0_cero, correct

#829

Hi @karips

  1. Does it makes sense to user the internal modifier for the owner variable?

Modifiers do not require to set visibility.

I tried to invoke the function in Remix after deploying, but the contract was not deleted, like pressing the trash bin button. Is there something wrong with the implementation or is this behavior normal?

selftdistruct() does not delete the contract therefore that is the normal behaviour.

Cheers,
Dani

1 Like
#830

Hey @kenn.eth

The selfdestruct() asks for a payable address as parameter :wink:

Cheers,
Dani

3 Likes
#831

I basically copied the close() function in the blog post, and extended the Ownable contract to inherit the onlyOwner modifier.

pragma solidity 0.7.5;

import "./Ownable.sol";

contract Destroyable is Ownable {
    
    function destroy() public onlyOwner {
        selfdestruct(owner);
    }
    
}