15f61ed0fd
I have gone through and updated all existing EIPs to match this rule, including EIP-1. In some cases, people were using markdown citations, I suspect because the long-form was a bit verbose to inline. Since the relative path is quite short, I moved these to inline but I wouldn't be opposed to putting them back to citation format if that is desired by the authors. In doing the migration/cleanup, I found some EIP references to EIPs that don't actually exist. In these cases I tried to excise the reference from the EIP as best I could. It is worth noting that the Readme actually already had this rule, it just wasn't expressed properly in EIP-1 and the "Citation Format" section of the readme I think caused people a bit of confusion (when citing externally, you should use the citation format).
3.8 KiB
| eip | title | author | type | category | status | created | requires |
|---|---|---|---|---|---|---|---|
| 926 | Address metadata registry | Nick Johnson <nick@ethereum.org> | Standards Track | ERC | Draft | 2018-03-12 | 165 |
Abstract
This EIP specifies a registry for address metadata, permitting both contracts and external accounts to supply metadata about themselves to onchain and offchain callers. This permits use-cases such as generalised authorisations, providing token acceptance settings, and claims registries.
Motivation
An increasing set of use cases require storage of metadata associated with an address; see for instance EIP 777 and EIP 780, and the ENS reverse registry in EIP 181. Presently each use-case defines its own specialised registry. To prevent a proliferation of special-purpose registry contracts, we instead propose a single standardised registry using an extendable architecture that allows future standards to implement their own metadata standards.
Specification
The metadata registry has the following interface:
interface AddressMetadataRegistry {
function provider(address target) view returns(address);
function setProvider(address _provider);
}
setProvider specifies the metadata registry to be associated with the caller's address, while provider returns the address of the metadata registry for the supplied address.
The metadata registry will be compiled with an agreed-upon version of Solidity and deployed using the trustless deployment mechanism to a fixed address that can be replicated across all chains.
Provider specification
Providers may implement any subset of the metadata record types specified here. Where a record types specification requires a provider to provide multiple functions, the provider MUST implement either all or none of them. Providers MUST throw if called with an unsupported function ID.
Providers have one mandatory function:
function supportsInterface(bytes4 interfaceID) constant returns (bool)
The supportsInterface function is documented in EIP-165, and returns true if the provider implements the interface specified by the provided 4 byte identifier. An interface identifier consists of the XOR of the function signature hashes of the functions provided by that interface; in the degenerate case of single-function interfaces, it is simply equal to the signature hash of that function. If a provider returns true for supportsInterface(), it must implement the functions specified in that interface.
supportsInterface must always return true for 0x01ffc9a7, which is the interface ID of supportsInterface itself.
The first argument to all provider functions MUST be the address being queried; this facilitates the creation of multi-user provider contracts.
Currently standardised provider interfaces are specified in the table below.
| Interface name | Interface hash | Specification |
|---|
EIPs may define new interfaces to be added to this registry.
Rationale
There are two obvious approaches for a generic metadata registry: the indirection approach employed here, or a generalised key/value store. While indirection incurs the cost of an additional contract call, and requires providers to change over time, it also provides for significantly enhanced flexibility over a key/value store; for that reason we selected this approach.
Backwards Compatibility
There are no backwards compatibility concerns.
Implementation
The canonical implementation of the metadata registry is as follows:
contract AddressMetadataRegistry {
mapping(address=>address) public provider;
function setProvider(address _provider) {
provider[msg.sender] = _provider;
}
}
Copyright
Copyright and related rights waived via CC0.