Inheritance Assignment

DearPhumi · March 30, 2021, 6:27pm

import “./Ownable.sol”;

contract Destroyable is Ownable {

function destroy() public onlyOwner {
selfdestruct(msg.sender);
}
}

serba · March 31, 2021, 8:43pm

Ownable.sol

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

Destroyable.sol

import "./Ownable";

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

Bank.sol

pragma solidity 0.7.5;

import "./Destroyable.sol";

contract Bank is Destroyable {
...
}

phyx1u5 · April 2, 2021, 9:07am

pragma solidity 0.7.5;

contract Ownable {
    
    address payable public owner;
    
    modifier onlyOwner {
        require(msg.sender == owner);
        _; //run the rest of the function after adding the line about to the modified function
    }
    
    constructor(){
        owner = msg.sender;
    }
}

contract Destroyable is Ownable {
    
    function close() public onlyOwner { //onlyOwner is custom modifier
        selfdestruct(owner);  // `owner` is the owners address
    }
}

NetworkP · April 2, 2021, 2:08pm

Very interesting. I made a couple of mistakes such as (1) I had ‘import “./Ownable.sol”;’ underneath Pragma solidity 0.7.5

(2) I forgot to put ‘address payable receiver = msg.sender;’ inside of the self destruct function, so my code was:

pragma solidity 0.7.5;

import “./Ownable.sol”;

contract Destroyable is Ownable {

function destroy() public onlyOwner {
selfdestruct(owner);
}
}

However, I do understand the concept.

Nicholas_Blom · April 3, 2021, 8:54am

import "./Ownable.sol";

contract Destroyable is Ownable {
    
    function close() public onlyOwner {
        selfdestruct(msg.sender);
    }
}

Bartek · April 3, 2021, 10:49am

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

contract Bank is Ownable, Destroyable

import "./Ownable.sol";

contract Destroyable is Ownable {
    
    function close() public onlyOwner {
        selfdestruct(msg.sender);
    }
}

bigbill · April 3, 2021, 11:22am

contract Ownable {
    
     address payable public owner;
     modifier onlyOwner {
        require(msg.sender == owner, 'only owner can perform action');
        _;
    }
    
     constructor(){
        owner = msg.sender;
    }
    
}

import "./Ownable.sol";
contract Destroyable is Ownable {
    
    function close() public onlyOwner {
        selfdestruct(owner);  
}
    
}

walacemaia · April 3, 2021, 9:46pm

/**
 * Contracts for which the owners must be known.
 */
contract Ownable {
    
    // internal as default
    address owner;
        
    modifier onlyOwner {
        require (msg.sender == owner,"Only contract owner can execute this function.");
        _; // run the function
    }
    // constructor
    constructor() {
        owner = msg.sender;
    }
}

pragma solidity 0.7.5;

import "./Ownable.sol";

/**
 * Contracts that can be destroyed.
 */
contract Destroyable is Ownable {
    
    function close () public {
        address payable _owner = payable(owner);
        selfdestruct (_owner);
    }
}

thecil · April 4, 2021, 4:05am

you could achieve the same by just assigning your owner variable has payable, or selfdestruct(payable(owner));

If you have any more questions, please let us know so we can help you!

Carlos Z.

Restford · April 4, 2021, 9:40am

pragma solidity 0.7.5;

contract Destroyable {
address public owner;

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

}

HanaYezi · April 4, 2021, 6:44pm

Screen Shot 2021-04-04 at 2.42.27 PM

REGO350 · April 5, 2021, 5:43am

My solution:
(Note: the code is written in version 0.8.3)

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

Paul_Kwok · April 5, 2021, 7:14am

pragma solidity 0.7.5;
import “./ownable.sol”;

contract Destroyable is Ownable {

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

}

Kamil37 · April 5, 2021, 11:40am

pragma solidity 0.7.5;

contract Destroyable {
    
    address owner;
    
    modifier onlyOwner {
        require(msg.sender == owner);
        _;
    }
    
    constructor() {
        owner = msg.sender;
    }
    
    function destroy() public onlyOwner {
        selfdestruct(msg.sender);
    }
}

Marcus_Hopkins · April 5, 2021, 6:46pm

Create a new contract called Destroyable!

pragma solidity >=0.8.3;

import “./ownable.sol”;

contract SelfDestruct is Ownable {

 function toSuicide() public onlyOwner{
   selfdestruct (msg.sender);
   }

}

cryptoleta · April 5, 2021, 8:30pm

Owner.sol

pragma solidity 0.7.5;
contract Owner{
    address owner;
    constructor(){
        owner=msg.sender;
    }
    modifier Onlyowner{
        require(msg.sender==owner);
        _;
    }
}

Destroyable.sol

pragma solidity 0.7.5;
import "./Owner.sol";
contract Destroyable is Owner{
    
    function selfdestructor()public Onlyowner{
        selfdestruct(msg.sender);
    }
    
}

bank.sol

pragma solidity 0.7.5;
import "./Owner.sol";
import "./Destroyable.sol";
    contract Bank is Owner,Destroyable{ 
    mapping(address =>uint)balance;     // etc, etc

dan-i · April 6, 2021, 7:14am

Hey @Marcus_Hopkins

From Solidity 0.8 msg.sender is not payable anymore by default.
You have to cast it to payable in order to use it as argument in selfdestruct().

Cheers,
Dani

shah1 · April 6, 2021, 1:24pm

import "./ownable.sol";
contract destroyable is ownable{
  function destruct() public  onlyowner {
      selfdestruct(owner);
  }  
}

Alex_Chaz · April 7, 2021, 1:38am

Ownable Contract.

pragma solidity 0.7.5;

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

Self Destruct Contract.

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

contract MrSelfDestruct is Ownable {
    function close() public onlyOwner {
        selfdestruct(owner);
    }
}

M.K · April 9, 2021, 1:33pm

pragma solidity 0.7.5;

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

constructor() public { 
      owner= msg.sender; 
}
}

pragma solidity 0.7.5; 

import "./ Ownable.sol"; 

contract Destroyable is Ownable { 
       function close () public onlyOwner {
       selfdestruct ( owner); // it does not matter whether it is msg.sender or owner right ? 
} 
}