Inheritance Assignment

Johnl · November 4, 2020, 9:55am

hi, here is my take on this assignment - cheers
https://github.com/lyonslj/solidity/tree/main/Inheritance

tomas819 · November 5, 2020, 12:21pm

the beginning of “MyContract” file

add import for the “Destroyable” contract
add inheritance Destroyable

pragma solidity 0.5.12;

import "./ownable.sol";
import "./destroyable.sol";

contract MyContract is Ownable, Destroyable {

File destroyable.sol

pragma solidity 0.5.12;

import "./ownable.sol";

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

thecil · November 6, 2020, 3:32am

Hehy @Johnl, hope you are great.

Now i dont think your solution on the destroyable contract is the best approach, if you are looking to fix the issue with the “payable” address, it is better to just change your ownable contract address to payable, or just convert it on your destroyable contract.

Although your solution could work, it takes more computing resources to calculate the same therefore, more gas fees at the end.

You also can define your owner address as payable at the begining of your Ownable contract in order to avoir the conversion (address(uint160(owner))) .

You can just use address payable public owner , then in your destroy function does not need the conversion.

Carlos Z

greentree · November 7, 2020, 4:16am

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

contract Destroyable is Ownable {

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

}

ArvidK · November 7, 2020, 12:49pm

Here is my solution.

pragma solidity 0.5.12;

contract Destroyable{
address public owner;

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

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

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

}

When I wrote selfdestruct(owner) it threw an error but it didn’t when I wrote msg.sender. Why is this? I am fairly certain I got it right anyway but please let me know if the code is faulty or that I need to improve it somehow.

BERGLUND · November 8, 2020, 2:54pm

I am a bit lost…

Adding to the main program sendTrans:

Creating the contract kill.sol

But somehow I lost the ability to add person etc…

BERGLUND · November 8, 2020, 6:59pm

How come reduced code does not decrease compilation time?
Does soilidity recognize functionality so even if I run rhe same function several times it doesn’t matter if the function is embedded in a child contract or not? Thus reducing the gas?

thecil · November 9, 2020, 12:20pm

Compilation time will take the same, instead of having 1 big contract with all the logic, you divided into many, using the inheritance, but for the compiler, it will be “run/compile this amount of code lines”, in that term, the compiler does not care if you have 1 big contract or multiple contracts.

For gas cost is the same, is not the inheritance who reduce the gas cost, its the way you code the logic (fewer instructions on a function logic will reduce gas costs).

Carlos Z.

thecil · November 9, 2020, 12:20pm

Could you show me the error that shows up when you try run the createPerson function? I need the code to help you

Carlos Z

BERGLUND · November 9, 2020, 3:00pm

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

contract sendTrans is Ownable, kill{

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(100){
  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(toTransfer);
return toTransfer;
}

}

thecil · November 9, 2020, 3:03pm

At the end of the function, your cost is 100 of what ???, I mean it should be costs(100 wei) or costs(100 ether)…maybe thats the only error.

Carlos Z

BERGLUND · November 9, 2020, 3:08pm

I did the assumption wei was default. I’ll change and try again.

BERGLUND · November 9, 2020, 3:15pm

Perhaps I just did the misstake @filip highlighted later: select the correct contract to deploy…

It seems to work fine.

BERGLUND · November 9, 2020, 3:24pm

And…the value must adjusted.

Joe1 · November 10, 2020, 6:58am

import “./Ownable.sol”;

pragma solidity 0.5.12;

contract Destroyable is Ownable {

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

}

pragma solidity 0.5.12;

contract Ownable{

address payable public owner;
  
modifier onlyOwner() {
    require(msg.sender == owner);
    _; //Continue execution
}

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

}
import “./Destroyable.sol”;

pragma solidity 0.5.12;

contract HelloWorld is Destroyable {

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

}

uint public balance;

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

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 must be below or 150");
    require(msg.value >= 1 ether);
    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);
    balance += msg.value;
    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)));
}

function insertPerson(Person memory newPerson) private {
    address creator = msg.sender;

// address payable test = address(uint160(creator)); // how to cast an address to a payable address; the other way is straight forward
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 {
    delete people[creator];
    assert(people[creator].age == 0);
}

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

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

// if (msg.sender.send(toTransfer)) {
// return toTransfer;
// } else {
// balance = toTransfer;
// return 0;
// }
return toTransfer;
}
}

loki · November 11, 2020, 6:14pm

Destroyable.sol:


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

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

HelloWorld.sol:

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

contract HelloWorld is Destroyable {
...
}

AKB_25 · November 12, 2020, 9:19pm

Destroyable Contract

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

contract Destroyable is Ownable {
//use the is keyword to inherit the Ownable contract
function close() public onlyOwner {
selfdestruct(msg.sender);
}
}

HelloWorld Contract

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

pragma solidity 0.5.12;

contract HelloWorld is Ownable, Destroyable{

_;

yana_holoborodko · November 13, 2020, 6:36am

Created destroyable contract, which inherits from Ownable.

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

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

And then included the Destroyable in HelloWorld:

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

contract HelloWorld is Ownable, Destroyable {
...

SoyBoy · November 13, 2020, 2:35pm

I created a Destroyable.sol contract, inheriting from Ownable.sol

import "./Ownable.sol";
pragma solidity 0.5.12;
contract Destroyable is Ownable {

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

Helloworld.sol contract then inherits from Destroyable.sol (as well as Ownable.sol through multi-level inheritance)

import "./Destroyable.sol";
pragma solidity 0.5.12;
contract HelloWorld is Destroyable { // and Destroyable is Ownable :)
...

Christophe_H · November 14, 2020, 1:52pm

From my understanding, the contracts are not yet deployed on the blockchain so it possible to add the delete function(selfdestruct) to the Ownable Contract. Creating a .sol file for just one function seem unecessary. We can then make the function internal so it can be run from the HelloWorld contract.

pragma solidity 0.5.12;

contract Ownable(){
   address public owner;

   modifier onlyOwner(){
      require(owner == msg.sender);
   }
    function close() internal onlyOwner{
   selftdestruct(owner);
   }
}