The Ownable-Transferable trait is almost identical to the Ownable trait that we covered in the previous example.
It adds one important feature which is the ability for the owner to transfer ownership to a new owner. This can also be used to renounce ownership completely by transferring ownership to an unusable address like the zero address.
If you're building a dapp and aiming for decentralization, always prefer this trait over Ownable. At some point in the dapps future, when you consider the owner role no longer unnecessary, you will be able to renounce ownership and make the dapp fully decentralized.
Use it in a contract just like Ownable. Define a state variable named owner: Address and call self.requireOwner() in priviliged receivers.
Your contract will automatically handle the ChangeOwner{newOwner: Address} message which allows the owner to transfer ownership.
// this trait has to be imported
import "@stdlib/stoppable";
import "@stdlib/ownable";
import "@stdlib/deploy";
// the Resumable trait allows the owner to stop/resume the contract which can limit certain actions
contract Counter with Deployable, Resumable {
owner: Address; // The Resumable trait requires you to add this exact state variable
stopped: Bool; // The Resumable trait requires you to add this exact state variable
val: Int as uint32;
init() {
self.owner = sender(); // we can initialize owner to any value we want, the deployer in this case
self.stopped = false;
self.val = 0;
}
// this message will only work as long as the contract is not stopped
receive("increment") {
self.requireNotStopped();
self.val = self.val + 1;
}
get fun value(): Int {
return self.val;
}
// receive("Resume") is added automatically to allow owner to resume the contract
// receive("Stop") is added automatically to allow owner to stop the contract
// get fun stopped(): Bool is added automatically to query if contract is stopped
// get fun owner(): Address is added automatically to query who the owner is
}