Inheritance Assignment

Crypto_Jeff · April 30, 2020, 8:38pm

Destroyable.sol:

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

contract Destroyable is Ownable {

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

HelloWorld.sol:

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

pragma solidity 0.5.12;

contract HelloWorld is Ownable, Destroyable{

struct Person {
  uint id;
  string name;
  uint age;
  uint height;
  bool senior;
}

event personCreated(string name, bool senior);
event personDeleted(string name, bool senior, address deletedBy);

uint public balance;

modifier costs(uint cost){
    require(msg.value >= cost);
    _;
}

mapping (address => Person) private people;
address[] private creators;

function createPerson(string memory name, uint age, uint height) public payable costs(1 ether){
  require(age < 150, "Age needs to be below 150");
  require(msg.value >= 1 ether);
  balance += msg.value;

    //This creates a person
    Person memory newPerson;
    newPerson.name = name;
    newPerson.age = age;
    newPerson.height = height;

    if(age >= 65){
       newPerson.senior = true;
   }
   else{
       newPerson.senior = false;
   }

    insertPerson(newPerson);
    creators.push(msg.sender);

    assert(
        keccak256(
            abi.encodePacked(
                people[msg.sender].name,
                people[msg.sender].age,
                people[msg.sender].height,
                people[msg.sender].senior
            )
        )
        ==
        keccak256(
            abi.encodePacked(
                newPerson.name,
                newPerson.age,
                newPerson.height,
                newPerson.senior
            )
        )
    );
    emit personCreated(newPerson.name, newPerson.senior);
}
function insertPerson(Person memory newPerson) private {
    address creator = msg.sender;
    people[creator] = newPerson;
}
function getPerson() public view returns(string memory name, uint age, uint height, bool senior){
    address creator = msg.sender;
    return (people[creator].name, people[creator].age, people[creator].height, people[creator].senior);
}
function deletePerson(address creator) public onlyOwner {
  string memory name = people[creator].name;
  bool senior = people[creator].senior;

   delete people[creator];
   assert(people[creator].age == 0);
   emit personDeleted(name, senior, owner);

}
function getCreator(uint index) public view onlyOwner returns(address){
return creators[index];
}

function withdrawAll() public onlyOwner returns(uint) {
uint toTransfer = balance;
balance = 0;
msg.sender.transfer(balance);
return toTransfer;
}

}

Glenn_CostaRica · May 2, 2020, 5:30am

Glenn_CostaRica

pragma solidity 0.5.12;

contract Ownable{ // PARENT
address payable public owner;

modifier onlyOwner(){
require(msg.sender==owner); // if not the Owner, abort execution!
_;
}

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

function getOwner()public view returns(address payable) { // this func gives you the Owner Add
return owner;
}

}

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

contract Destroyable is Ownable{ // CHILD

function destroyContract() public onlyOwner { //onlyOwner-> modifier in the Parent contract
address payable toDestroy = getOwner();
selfdestruct(toDestroy); // `“owner”-> owners address
}

}

gabba · May 2, 2020, 3:55am

Hi @Glenn_CostaRica

Did you try your code in remix ?
Your function getOwner won’t work for 2 reasons:

first you should use return instead of returnS
returnS is only used your function prototype declaration, inside the function if you want to return a value you should use return.
The second issue is the type you are using, in solidity 0.5.12 the selfdestruct function is taking a variable of type “address payable” as parameter.

gabba · May 2, 2020, 3:59am

@SimonLondon @Spartak @Crypto_Jeff @Glenn_CostaRica

Don’t forget to use this balise to display your code.

It’ll make your answers more readable

Glenn_CostaRica · May 2, 2020, 4:47am

@gabba Thank you sooo much <3 Yes, I had a problem with returns --> return It took me a few minutes to find the problem !!! I should’ve checked here first !! About not having used PAYABLE for my address-type variable, I discovered the problem when I re-watched Filip’s video !!!.. In the end, my code worked: but, I found Filip’s solution was so much nicer and simpler !!!

Glenn_CostaRica · May 2, 2020, 5:31am

@gabba I just fixed my publication, up here, with the code that actually ran well in remix !! Thank you again !!! <3

Glenn_CostaRica · May 2, 2020, 5:33am

BTW…, I am so excited !! This course has been amazing !! I don’t sleep or think about anything else these days LOVE FROM COSTA RICA AND ALSO JAPAN ( ): I have two hearts !!!

gabba · May 2, 2020, 5:45am

great @Glenn_CostaRica
You will see during eth 210 you will be able to develop a complete Dapp it’s really cool

Glenn_CostaRica · May 2, 2020, 5:59am

@gabba Man!! It sounds awesome!! I’m crazy about taking the 201 course <3<3<3 I’ve been an Ethereum super fan for very long time. I’ve studied so much about Ethereum theoretically. Now, that I am actually learning how to code in Solidity, I truly feel part of a big thing! Part of such an amazing thing! I live and work in Costa Rica now. But, my kids (son and daughter) are in Japan. I speak with them almost everyday, and recently all I talk about is Programming_in_Ethereum!

Mislav_Bajan · May 2, 2020, 12:46pm

Created new sol file Destroyable.sol

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

contract Destroyable is Ownable{

function close() public onlyOwner{
    selfdestruct(address(uint256(owner)));    
}

}

and added inheritance in HelloWorld.sol

contract HelloWorld is Ownable, Destroyable{…}

jsizzle · May 2, 2020, 2:28pm

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

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

Luca_del_Grosso · May 2, 2020, 6:31pm

I did do as per the video the when creating Destroyable.sol i wrote this in it:

import “./Ownable.sol”;

pragma solidity 0.5.12;

contract Destroyable is Ownable{

address payable test=address(uint160(owner));

function destruction() internal onlyOwner {

selfdestruct(test);

}

I did import this contract to HelloWorld as well and i changed the address owner to internal too.

timtim · May 3, 2020, 6:44pm

New file called Destroyable.sol:

import "./Ownable.sol";

pragma solidity 0.5.12;



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

Import Destroyable.sol to child contract HelloWorld.sol:

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

pragma solidity 0.5.12;

contract HelloWorld is Ownable, Destroyable  {

alexglebov · May 3, 2020, 9:34pm

pragma solidity 0.5.12;

contract Ownable {
address payable internal owner;

modifier onlyOwner() {
    require(msg.sender == owner);
    _;
}

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

}

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

contract Destructable is Ownable {

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

}

import “./Destructable.sol”;
pragma solidity 0.5.12;

contract HelloWorld is Destructable {
…
}

Warbug · May 4, 2020, 4:20am

Create destroyable contract

import "./Ownable.sol";

pragma solidity 0.5.12;

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

}

Import Destroyable.sol into HelloWorld contract
Add Destroyable to HelloWorld contract inheritance

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

pragma solidity 0.5.12;

contract HelloWorld is Ownable, Destroyable{

agonzo12 · May 4, 2020, 7:08am

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

contract Destroyable is Ownable {
    function destroyContract() public {
        selfdestruct(address(uint160(owner)));
    }
}

prassie · May 4, 2020, 9:07pm

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

contract CloseContract is Ownable {

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

}
HelloWorld has to extend this CloseContract

Anton_Nortje · May 5, 2020, 11:57am

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

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

I changed ‘owner’ to a payable address in the Ownable contract:

contract Ownable {
    address payable public owner;

gabba · May 5, 2020, 12:46pm

Hi @timtim
Your contract HelloWorld doesn’t have to inherit from the Ownable contract as the Destroyable contract is inheriting from it.

JRB · May 6, 2020, 12:40am

@filip @gabba

I can’t seem to figure out how to get the onlyOwner modifier to work in the Destroyable contract file. Please Help.

Here is the modifier in case thier is somthing wrong with it.

// modifier onlyOwner
    modifier onlyOwner(){
        require(msg.sender == owner);
        _;
    }

Here is the contract Destroyable.

pragma solidity 0.5.12;

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

Let me know If you need more information or display of code. This is my first time asking for help.