ERC-5313 — Light Contract Ownership

Back to Account & Authentication

ERC-5313: Light Contract Ownership

ERC-5313 strips ERC-173 down to its single most useful method — owner() returning the current owner address — and removes the transferOwnership write path. The motivation: tons of contracts only need to expose an owner for off-chain tools (block explorers, indexers, wallet UIs) without committing to ERC-173's transfer semantics. Diamond contracts, multisigs, and DAO-governed proxies all have an "owner" in some sense, but their actual ownership-change flow is custom (governance vote, multisig threshold, etc.).

ERC-5313 lets these contracts advertise their owner uniformly without implementing ownership transfer at all.

Required Interface

interface IERC5313 {
    function owner() external view returns (address);
}

That's it — one read-only method. ERC-173 implementations satisfy ERC-5313 automatically; the inverse is not true (ERC-5313 contracts don't need transferOwnership).

Neo Equivalent: getOwner() View Convention

Most production Neo contracts already expose a getOwner view that returns the contract's UInt160 owner — the convention predates any standard. ERC-5313 is essentially the formalisation of that convention.

ERC-5313 (Ethereum)	Neo Equivalent
function owner() returns (address)	public static UInt160 GetOwner() view method
Owner stored in any mechanism (constructor arg, init slot, governance result, …)	Owner stored in any mechanism (_deploy callback init, NEP-22 update set, governance contract result, …)
ERC-173 satisfies this trivially	Existing ERC-173 mirror entries satisfy this trivially

When To Use This vs ERC-173

• ERC-173 when ownership is held by a single account that may occasionally transfer (the simple case — most early-stage contracts).
• ERC-5313 when the contract has an "owner" concept but the ownership-change path is non-trivial (governance vote, multisig approval, time-locked upgrade) and shouldn't be hidden behind a single transferOwnership(address) method.

For Diamond proxies (see ERC-2535), ERC-5313 is the right fit because the "owner" is really the diamond's executive facet, and changing it goes through the cut-facet flow rather than a plain transfer.

Migration Notes

If you're porting an ERC-5313 contract to Neo:

• Rename owner() to GetOwner() (Neo C# convention) or keep owner if using neo-solc directly (the dispatcher matches by-method-name).
• Store the owner wherever makes sense — a simple constant slot for immutable ownership, a Storage key for governance-managed ownership.
• For Diamond-style contracts, the getOwner resolves to whatever facet controls executive operations — usually a separate governance contract hash, not a hot-key address.

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

interface IERC5313 {
    function owner() external view returns (address);
}

// Example: a contract whose ownership is governed by a multisig.
// It exposes an owner() view but doesn't expose any transfer mechanism —
// the multisig changes ownership through its own governance flow.
contract GovernedContract is IERC5313 {
    address private _governance;  // multisig contract address

    constructor(address governance) { _governance = governance; }

    function owner() external view returns (address) { return _governance; }

    // No transferOwnership — that would imply hot-key control.
    // Governance updates happen through the multisig's own propose/execute flow.
}

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("GovernedContract")]
[ContractPermission("*", "*")]
public class GovernedContract : SmartContract
{
    private const byte Prefix_Governance = 0x01;

    [DisplayName("_deploy")]
    public static void Deploy(object data, bool update)
    {
        if (update) return;
        var governance = (UInt160)data;
        Storage.Put(Storage.CurrentContext, new byte[] { Prefix_Governance }, governance);
    }

    public static UInt160 GetOwner()
        => (UInt160)Storage.Get(Storage.CurrentContext, new byte[] { Prefix_Governance });

    // No SetOwner — governance changes flow through the multisig contract itself.
    // The contract is owned-by-governance, not owned-by-hotkey.
}

Combining With ERC-173

A contract can implement both ERC-173 and ERC-5313 by exposing the same method (owner / GetOwner) and additionally providing transferOwnership / SetOwner for the simple-case. ERC-5313 is a subset of ERC-173 — same method, fewer guarantees about what else exists.