ERC-173 — Contract Ownership

Back to Account & Authentication

ERC-173: Contract Ownership Standard

ERC-173 standardises the basic admin-ownership pattern: a contract has a single owner, ownership can be transferred, admin functions check ownership.

Required Interface

function owner() external view returns (address);
function transferOwnership(address newOwner) external;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

OpenZeppelin's Ownable is the de facto reference; the two-step Ownable2Step variant avoids the "transfer to wrong address, lose contract" footgun.

Neo Equivalent

Neo doesn't standardise owner() because it would be redundant. Every Neo contract:

• Has its _deploy callback (NEP-29) where you set the initial owner.
• Has a manifest-defined update method (NEP-22) for admin operations.
• Uses Runtime.CheckWitness(owner) to gate any admin function.

Most production contracts expose a getOwner view as a convention but it's not required by any standard.

Live on Neo TestNet

Both implementations deployed on Neo N3 TestNet.

Implementation	TestNet Address	Contract Hash
Solidity (neo-solc)	NgmPfqiGc6weStAM5PYBgC4SYgTGUZzPVh	0x19977aea…1156bbe4
Neo C# (nccs)	NU3yPrTayUJRB16Lu8RjFX8ERJ7pMYvxup	0xce89aec2…11824459

Verified: getOwner == deployer, claimOwnership (Solidity), _deploy-time owner init (C#). docs/standards-mirror/deployments/erc-173/.

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

abstract contract Ownable2Step {
    address private _owner;
    address private _pendingOwner;

    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

    constructor(address initialOwner) { _owner = initialOwner; }

    modifier onlyOwner() {
        require(msg.sender == _owner, "Ownable: caller is not the owner");
        _;
    }

    function owner() public view returns (address) { return _owner; }
    function pendingOwner() public view returns (address) { return _pendingOwner; }

    function transferOwnership(address newOwner) public onlyOwner {
        _pendingOwner = newOwner;
    }

    function acceptOwnership() public {
        require(msg.sender == _pendingOwner, "not pending");
        address old = _owner;
        _owner = _pendingOwner;
        delete _pendingOwner;
        emit OwnershipTransferred(old, _owner);
    }

    function renounceOwnership() public onlyOwner {
        address old = _owner;
        _owner = address(0);
        emit OwnershipTransferred(old, address(0));
    }
}

using System;
using System.ComponentModel;
using Neo;
using Neo.SmartContract.Framework;
using Neo.SmartContract.Framework.Attributes;
using Neo.SmartContract.Framework.Native;
using Neo.SmartContract.Framework.Services;

namespace R3E.Examples;

[DisplayName("OwnableContract")]
[ContractPermission("*", "*")]
public class OwnableContract : SmartContract
{
    private static readonly byte[] OwnerKey        = { 0xff, 0x01 };
    private static readonly byte[] PendingOwnerKey = { 0xff, 0x02 };

    [DisplayName("OwnershipTransferred")]
    public static event Action<UInt160, UInt160> OnOwnershipTransferred;

    public static UInt160 GetOwner()
        => (UInt160)Storage.Get(Storage.CurrentContext, OwnerKey);

    public static UInt160 PendingOwner()
        => (UInt160)Storage.Get(Storage.CurrentContext, PendingOwnerKey);

    public static void TransferOwnership(UInt160 newOwner)
    {
        if (!Runtime.CheckWitness(GetOwner())) throw new Exception("owner only");
        if (!newOwner.IsValid)                 throw new Exception("invalid newOwner");
        Storage.Put(Storage.CurrentContext, PendingOwnerKey, newOwner);
    }

    public static void AcceptOwnership()
    {
        var pending = PendingOwner();
        if (pending == null || !Runtime.CheckWitness(pending))
            throw new Exception("not pending owner");
        var prev = GetOwner();
        Storage.Put(Storage.CurrentContext, OwnerKey, pending);
        Storage.Delete(Storage.CurrentContext, PendingOwnerKey);
        OnOwnershipTransferred(prev, pending);
    }

    /// <summary>NEP-22: standard update method, replaces ERC-1967 proxy upgrade.</summary>
    public static void Update(ByteString nefFile, string manifest, object data)
    {
        if (!Runtime.CheckWitness(GetOwner())) throw new Exception("owner only");
        ContractManagement.Update(nefFile, manifest, data);
    }

    public static void _deploy(object data, bool update)
    {
        if (update) return;
        var initialOwner = (UInt160)data;
        Storage.Put(Storage.CurrentContext, OwnerKey, initialOwner);
        OnOwnershipTransferred(UInt160.Zero, initialOwner);
    }
}