Token Contract – How to Transfer Ownership of a Token Contract

openzeppelinsoliditytokens

I'm trying to create a token contract using openzeppelin. I managed to create the token using the ownable contract from ownable.sol, which let me transfer the ownership of the token contract.

However, I need to transfer the token contract ownership to a crowdsale contract. I'm wondering if there is a way to reclaim/transfer the token contract ownership to another address.

Here's at a glance what I'm trying to do.

Token contract created [solved]
Crowdsale contract created [solved]
Token contract ownership transferred to the crowdsale contract address [solved]
Transfer the Token contract ownership to another address. [NEED SOLUTION]

Any suggestion?

Best Answer

Ownable.sol has the following method:

/**
   * @dev Allows the current owner to transfer control of the contract to a newOwner.
   * @param newOwner The address to transfer ownership to.
   */
  function transferOwnership(address newOwner) public onlyOwner {
    require(newOwner != address(0));
    OwnershipTransferred(owner, newOwner);
    owner = newOwner;
  }

If you want to transfer ownership of the token contract (and assuming the token is Ownable) you can call transferOwnership(address_of_new_owner) using the account that currently owns the token contract.

Have in mind that unless the crowdsale contract that now owns the token also implements a function that can call this function, you won't be able to transfer ownership back again if you wanted so.

Here's an example.

You have the token contract with the transferOwnership() function above. The current owner is your own account.
You call that function passing the address of the crowdsale. Now the owner = (the crowdsale).
If you now wanted to transfer ownership from the crowdsale to another account, the only one that can do so is the actual crowdsale contract as it is the current owner.

For that to be possible, the crowdsale contract would have to have the following code:

function transferOwnership(address _newOwner) public onlyOwner {
  require(msg.sender == owner); // Only the owner of the crowdsale contract should be able to call this function.

  // I assume the crowdsale contract holds a reference to the token contract.
  token.transferOwnership(_newOwner);

}

Related Solutions

Crowdsale Contract – How to Mint Tokens in Another Token Contract

Yes what you need to do is first create your token in a separate contract. Then when you create your crowdsale you pass in the constructor the address of your token.

This is a sample taken from the Ethereum Crowdfund your idea

pragma solidity ^0.4.16;

interface token {
    function mintToken(address receiver, uint amount);
}

contract Crowdsale {
    token public tokenReward;

    /**
     * Constrctor function
     */
    function Crowdsale(
        address addressOfTokenUsedAsReward
    ) {
        tokenReward = token(addressOfTokenUsedAsReward);
    }
}

Solidity – Transfer Ownership of a Contract in Constructor

I have run the code in remix with the according complements for owner and ERC721CrowdSale and your code worked fine. I only slightly modified your contract so that I would get the value of the current owner of the crowdsale returned by the function create_crowdsale(...).

pragma solidity ^0.4.19;

contract Ownable {

    address public owner;

    function Ownable() public {
        owner = msg.sender;
    }

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

    function transferOwnership(address _newOwner) public onlyOwner {
        owner = _newOwner;
    }
}

contract ERC721CrowdSale is Ownable {

    string public name;
    address public wallet;
    uint256 public token_goal;

    function ERC721CrowdSale(string _name, address _wallet, uint256 _token_goal) public {
        name = _name;
        wallet = _wallet;
        token_goal = _token_goal;
    }
    //...

}

contract CS_Creator is Ownable{
  ERC721CrowdSale _cs;

  function create_crowdsale(string _name, address _wallet, uint256 _token_goal) onlyOwner returns(address, address){
      address _new_crowdsale = new ERC721CrowdSale(_name,  _wallet,  _token_goal);
      transfer_CS_ownership(_new_crowdsale, _wallet);
      return (_new_crowdsale, get_CS_ownership(_new_crowdsale));
  }

  function transfer_CS_ownership(address _new_crowdsale, address _wallet)  internal {
      _cs = ERC721CrowdSale(_new_crowdsale);
      _cs.transferOwnership(_wallet);
  }

  function get_CS_ownership(address _crowdsale) public returns(address) {
      return ERC721CrowdSale(_crowdsale).owner();
  }
}

As a return value for the crowdsale owner I get the value for the wallet address.

I could imagine that you actually created a contract ERC721CrowdSale in remix and then were checking there whether the owner address had changed, after deploying CS_Creator. If so: in this case you are creating a new instance of the contract ERC721CrowdSale with the function create_crowdsale(...) which, therefore, is completely independent from the other ERC721CrowdSale contract, you deployed earlyer. The owner address, however, is only changed in the instance, created by the function create_crowdsale(...).

Hope it helps!

Best Answer

Related Solutions

Crowdsale Contract – How to Mint Tokens in Another Token Contract

Solidity – Transfer Ownership of a Contract in Constructor

Related Topic