Inheritance Assignment

Ethereum Smart Contract Programming 101
#1359

import “./Ownable.sol”;

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

pragma solidity 0.7.5;

import “./Ownable.sol”;
import “./SelfDestruct.sol”;

contract Bank is Ownable, SelfDestruct {

}

1 Like
#1360

Destroyable:

pragma solidity 0.7.5;

import "./Ownable.sol";

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

Ownable:

pragma solidity 0.7.5;

contract Ownable  {
    address payable public owner;
    
    modifier onlyOwner {
       require (msg.sender == owner);
       _; //Run The Function
   }
   
   constructor(){
       owner = msg.sender;
   }
    
}

Bank:

pragma solidity 0.7.5;


import "./Destroyable.sol";

contract Bank is Destroyable {
    
   mapping(address => uint) balance;
   
   event depositDone(uint amount, address depositedTo);
   
   event transferMade(uint amount, address depositedTo, address depositedFrom);
   
   event withdrawDone(uint amount, address withdrawTo);
   
   
   function deposit() public payable returns (uint){
       balance[msg.sender] += msg.value;
       emit depositDone(msg.value, msg.sender);
       return balance[msg.sender];
   }
   
   function withdraw(uint amount) public returns (uint){
      require(balance[msg.sender] >= amount, "Balance not sufficient");
      balance[msg.sender]-=amount;
      msg.sender.transfer(amount);
      return balance[msg.sender];
      
      emit withdrawDone(amount, msg.sender);
   }
   
   function getBalance() public view returns (uint){
       return balance[msg.sender];
   }
   
   function transfer(address recipient, uint amount) public {
       require(balance[msg.sender] >= amount, "Balance not sufficient");
       require(msg.sender != recipient, "Dont send money to yourself");
       
       uint previousSenderBalance = balance[msg.sender];
       
       _transfer(msg.sender, recipient, amount);
       
       assert(balance[msg.sender] == previousSenderBalance - amount);
       
       emit transferMade(amount, msg.sender, recipient);
   }
   
   function _transfer(address from, address to, uint amount) private {
       balance[from] -= amount;
       balance[to] += amount;
   }
}
1 Like
#1361

Ownable.sol

pragma solidity ^0.7.5;

contract Ownable {
    address owner;
    modifier isOwner(address  _addr){
       require( owner == _addr,"Sender is not owner!");
        _;
    }
   
    constructor(){
        owner= msg.sender;
    }
 }

Destroyable.sol

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

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

Inheritance.sol

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

contract Inheritance is Destroyable {
}
1 Like
#1362

Assignment:

pragma solidity 0.7.5;
contract Destroyable {
address private owner
modifier onlyOwner() {
require(msg.sender == owner);
}
constructor () {
owner = msg.sender;
}
function close () private {
selfDestruct(msg.sender);
}
}

1 Like
#1363

pragma solidity 0.7.5;

import “./Ownable.sol”;
import “./Destoyable.sol”;

contract Bank is Destoyable{

===================================

pragma solidity 0.7.5;

import “./Ownable.sol”;

contract Destoyable is Ownable {

function close() public onlyOwner { 
selfdestruct(msg.sender);

}
}

===================================

pragma solidity 0.7.5;

contract Ownable {
address public owner;

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

}

1 Like
#1364

pragma solidity >0.7.5 < 0.9.5;
contract Ownable {
address payable private owner;

constructor() {
owner = msg.sender;
}

function byebye() public {
selfdestruct(owner);
}
}

pragma solidity >0.7.5 < 0.9.5;
/.practice.sol;
contract Destroyable is Ownable {
address payable private owner;

constructor() {
owner = msg.sender;
}

function byebye() public {
selfdestruct(owner);
}
}

1 Like
#1365

hii @filip…did not understand this code

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

why we used address payable receiver

pragma solidity >0.6.0;
contract Storage {
address payable private owner;
uint256 number;
constructor() {
owner = msg.sender;
}
function store(uint256 num) public {
number = num;
}
function retrieve() public view returns (uint256){
return number;
}

function close() public {
selfdestruct(owner);
}
}

why this was not used above i.e address payable receiver =msg.sender

THANK YOU

1 Like
#1366

The payable keyword, allows an address to be able to receive native funds (ethereum on this case).

So the selfdestruct function will destroy the contract but is will need a payable address to sent the remaining funds of the contract to it .

Carlos Z

#1367

Ownable.sol

pragma solidity 0.7.5;

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

Terminate.sol

pragma solidity 0.7.5;

import "./ownable.sol";

contract Terminate is Ownable {
    
    function destroy () public onlyOwner {
        selfdestruct(msg.sender);
    }
    
}

Bank.sol

pragma solidity 0.7.5;

import "./terminate.sol";

contract Bank is Terminate {
    
    
    mapping(address => uint) balance;
    event depositDone(uint amount, address indexed depositedTo);
    
    
    function deposit() public payable returns (uint)  {
        balance[msg.sender] += msg.value;
        emit depositDone(msg.value, msg.sender);
        return balance[msg.sender];
    }
    
    
    function withdraw(uint amount) public returns (uint){
        require(balance[msg.sender] >= amount);
        balance[msg.sender] -= amount;
        msg.sender.transfer(amount);
        return balance[msg.sender];
    }
    
    
    function getBalance() public view returns (uint){
        return balance[msg.sender];
    }
    
    
    function transfer(address recipient, uint amount) public {
        require(balance[msg.sender] >= amount, "Balance insufficient");
        require(msg.sender != recipient, "Can't transfer $$$ to yourself");
        
        uint previousSenderBalance = balance[msg.sender];
        
        _transfer(msg.sender, recipient, amount);
                
        assert(balance[msg.sender] == previousSenderBalance - amount);
    }
    
    
    function _transfer(address from, address to, uint amount) private {
        balance[from] -= amount;
        balance[to] += amount;
    }
    
}

i hope this is right

1 Like
#1368

The way i have this set up bank.sol is destructable, destruct.sol is ownable. Ownable being the base contract destruct is deriveing from, and bank.sol deriving from destruct.sol

bank.sol 
pragma solidity 0.7.5;

import "./destruct.sol";

contract Bank is Destructable {
    
    mapping(address => uint256) balance;
Ownable.sol 
pragma solidity 0.7.5;

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

}
Destruct.sol 
pragma solidity 0.7.5;

import "./assignment.sol";

contract Destructable is Ownable {
 
  function destroy() public onlyOwner payable {
        selfdestruct(owner);
    }
}
1 Like
#1369

1a) _Destructable.sol :

pragma solidity 0.7.5;

import "./Ownable.sol";

contract Destructable is Ownable {
    
   function destroy() public onlyOwner { 
  selfdestruct(msg.sender); 
 }
}

1b) Ownable.sol :

pragma solidity 0.7.5;

contract Ownable {
    address public owner;
    
    modifier onlyOwner {
        require(msg.sender == owner);
        _;
    }
    
    constructor(){
    owner = msg.sender;
    }
}
  1. Bankcontract.sol :
pragma solidity 0.7.5;

import "./Ownable.sol";
import "./_Destructable.sol";

contract Bank is Ownable,  Destructable {
    
    mapping(address => uint) balance;
    
    event depositDone(uint amount, address indexed depositedTo);
    
    function deposit() public payable returns (uint)  {
        balance[msg.sender] += msg.value;
        emit depositDone(msg.value, msg.sender);
        return balance[msg.sender];
    }
    
    function withdraw(uint amount) public onlyOwner returns (uint){
        require(balance[msg.sender] >= amount);
        balance[msg.sender] -= amount;
        msg.sender.transfer(amount);
        return balance[msg.sender];
    }
1 Like
#1370

Hi Philip, there is my answer :slight_smile:

//Ownable contract
pragma solidity 0.7.5;

contract Ownable {
address payable owner;

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

}

// Destroyable contract
pragma solidity 0.7.5;

import “./Ownable.sol”;

contract Destroyable is Ownable {

    constructor() {
    address payable owner = msg.sender;
    }

    
    function close() public payable onlyOwner {
    require(msg.sender == owner, "You are not the owner");
    selfdestruct(msg.sender); 
     }

// Bank contract

pragma solidity 0.7.5;

import “./Ownable.sol”;
import “./Destroyable.sol”;

contract Bank is Ownable, Destroyable {

1 Like
#1371 
import “./Ownable.sol”;
pragma solidity 0.5.12;
contract selfDestruct is Ownable{
function destroycontract() public onlyOwner {
selfdestruct (address(uint160(owner)));
}
}
1 Like
#1372 
pragma solidity 0.7.5;

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

pragma solidity 0.7.5;

import "./Ownable.sol";

contract Destroyable is Ownable {
    
    function transferAndScram () internal OnlyOwner {
        selfdestruct (owner);
    }
}```

pragma solidity 0.7.5;

import “./DestroyableO.sol”;

contract Bank is Destroyable {

mapping (address => uint) balance; 

event movementDone (uint amount, address indexed depositedTo); 

function deposit () public payable returns (uint){
    balance[msg.sender] += msg.value; 
    emit movementDone (msg.value , msg.sender);
    return (balance[msg.sender]); 
}

function withdraw (uint amount) public returns (uint){
    require (balance[msg.sender]>=amount); 
    msg.sender.transfer(amount); 
    balance[msg.sender] -= amount;
    emit movementDone(-amount, msg.sender);
    return (balance[msg.sender]); 
}

function getBal() public view returns (uint){
    return balance[msg.sender]; 
}
function transferR (address recipient, uint amount) public{
    require (balance[msg.sender]>=amount, "Not enough balance");
    require (msg.sender != recipient, "Don't transfer money to yourself !"); 
    uint preTransferSenderBal = balance[msg.sender]; 
    _transfer(msg.sender,recipient,amount);
    assert(balance[msg.sender] == preTransferSenderBal-amount);
}

function _transfer (address from, address to, uint amount) private {
    balance[from] -= amount;
    balance[to] += amount;
}

}



I don t see how to make deposit function "inactive" after selfdestruct ?.. here it is still possible to use deposit function to send eth to a selfdectructed contract that can not accept any more eth.. so sending is possible but not depositing..
is it possible to use a "require() " in deposit function body ? to check if selfdestruct has been executed or not ..?
#1373

The upper part of my bank contract. I’ve added a import destroyable link and below i’ve added a destroy to is.

pragma solidity 0.7.5;
import "./ownable.sol";
import"./destroyable.sol";

    contract Bank is Ownable, destroy{

pragma solidity 0.7.5;

import “./ownable.sol”;

the destroyfunction copied from the article and made ownable

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

and of course a third document with our ownable contract from before.

#1374

pragma solidity 0.7.5;

contract Ownable {

address payable public owner;

modifier onlyOwner {
    require(msg.sender == owner, "You're not the owner.");
    _;
}

constructor () {
    owner = msg.sender;
}

}

pragma solidity 0.7.5;

import “./Ownable.sol”;

contract Destroyable is Ownable {

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

}

pragma solidity 0.7.5;

import “./Ownable.sol”;

import “./Destroyable.sol”;

contract BankUsingPayable is Ownable, Destroyable {

1 Like
#1375

Ownable

pragma solidity 0.7.5;

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

Destroyable


pragma solidity 0.7.5;

import "./Ownable.sol";

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

Hello world

pragma solidity 0.7.5;

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

contract Bank is Destroyable {
...
}
1 Like
#1376

Ownable.sol

pragma solidity 0.7.5;

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

Destroyable.sol

pragma solidity 0.7.5;

import './Ownable.sol';

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

Bank.sol

pragma solidity 0.7.5;

import './Destroyable.sol';

contract Bank is Destroyable {...}
1 Like
#1377

Ownable.sol:

pragma solidity 0.8.7;

contract Ownable{
    address owner;
    
    constructor(){
        // This way the contract deployer is always the owner
        owner = msg.sender;
    }
    modifier onlyOwner{
        require(msg.sender==owner, "Access Denied");
        _; // In practice: Run the function; Compiler code in practice it marks the point of editing
    }
}

Destroyable.sol:

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

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

Bank.sol:

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

contract Bank is Ownable, Destroyable{
    mapping(address => uint) balance;
    // Assert costs are available
    
    modifier costs(uint price) {
        require(msg.value >= price);
        _;
    }
    modifier Covered(uint amount) {
        require(balance[msg.sender] >= amount,"Nice try.");
        _;
    }
    
    event balanceAdded(uint amount, address indexed AddedTo);
    event depositDone(uint amount, address indexed AddedTo);
    event withdrawDone(uint amount, address indexed WithdrawnTo);
    
    function deposit() public payable returns(uint){
        balance[msg.sender] += msg.value;
        emit depositDone(msg.value, msg.sender);
        return balance[msg.sender];
    }
    function withdraw(uint amount) public Covered(amount) returns(uint) {
        payable(msg.sender).transfer(amount);
        balance[msg.sender] -= amount;
        emit withdrawDone(amount, msg.sender);
        return balance[msg.sender];
    }
    
    function getBalance() public view returns(uint) {
        return balance[msg.sender];
    }
    function transfer(address recipient, uint amount) public {
        // Error handling and check coming up later...
        require(amount <= balance[msg.sender], "Insufficient balance");
        require(msg.sender != recipient, "Cant transfer to self");
        uint PreviousSenderBalance = balance[msg.sender];
        uint PreviousRecipientBalance = balance[recipient];
        _transfer(msg.sender,recipient,amount);
        // Event logs and further checks
        assert(balance[msg.sender] == PreviousSenderBalance - amount);
        assert(balance[recipient] == PreviousRecipientBalance + amount);
        emit balanceAdded(amount,recipient);
    }
    function _transfer(address from, address to, uint amount) private {
        balance[from] -= amount;
        balance[to] += amount;
    }
}

It seems to work except for one odd thing. Even after the contract has self-destructed it seems to remain interactable. You can send ETH to it with the deposit() function, but noone can get that ETH back, not even the creator when pushes the BigRedButton (again). Is this normal? Shouldn’t the functions of a self-destructed contract become unavailable?

2 Likes
#1378

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

contract Destroyable is Ownable {

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

1 Like