EIP-725: General key-value store and execution standard

Simple Summary

A standard interface for a smart contract based account with attachable key value store.

Abstract

The following describes standard functions for a unique smart contract based account that can be used by humans, groups, organisations, objects and machines.

The standard is divided into two sub standards:

ERC725X: Can execute arbitrary smart contracts and deploy other smart contracts.

ERC725Y: Can hold arbitrary data through a generic key/value store.

Motivation

Standardizing a minimal interface for a smart contract based account allows any interface to operate through these account types. Smart contact based accounts following this standard have the following advantages:

• can hold any asset (native token, e.g. ERC20 like tokens)
• can execute any smart contract and deploy smart contracts
• have upgradeable security (through owner change, e.g. to a gnosis safe)
• are basic enough to work for for a long time
• are extensible though additional standardisation of the key/value data.
• can function as an owner/controller or proxy of other smart contracts

Specification

ERC725X

ERC165 identifier: 0x44c028fe

execute

function execute(uint256 operationType, address to, uint256 value, bytes calldata data) public payable returns(bytes memory)

Executes a call on any other smart contracts, transfers the blockchains native token, or deploys a new smart contract. MUST only be called by the current owner of the contract.

Parameters:

• operationType: the operation to execute.
• to: the smart contract or address to interact with. to will be unused if a contract is created (operation 1 and 2).
• value: the value of ETH to transfer.
• data: the call data, or the contract data to deploy.

Returns: bytes , the returned data of the called function, or the address of the contract created (operation 1 and 2).

The operationType can execute the following operations:

• 0 for call
• 1 for create
• 2 for create2
• 3 for staticcall
• 4 for delegatecall

Others may be added in the future.

Triggers Event: ContractCreated, Executed

Events

Executed

event Executed(uint256 indexed _operation, address indexed _to, uint256 indexed _value, bytes _data);

MUST be triggered when execute creates a new call using the operationType 0, 3, 4.

ContractCreated

event ContractCreated(uint256 indexed _operation, address indexed _contractAddress, uint256 indexed _value);

MUST be triggered when execute creates a new contract using the operationType 1, 2.

ERC725Y

ERC165 identifier: 0x5a988c0f

getData

function getData(bytes32[] memory _keys) public view returns(bytes[] memory)

Gets array of data at multiple given key.

Parameters:

• _keys: the keys which values to retrieve.

Returns: bytes[] , array of the values for the requested keys.

setData

function setData(bytes32[] memory _keys, bytes[] memory _values) public 

Sets array of data at multiple keys. MUST only be called by the current owner of the contract.

Parameters:

• _keys: the keys which values to retrieve.
• _values: the array of bytes to set.

Triggers Event: DataChanged

Events

DataChanged

event DataChanged(bytes32 indexed key, bytes value)

MUST be triggered when setData was successfully called.

Ownership

This contract is controlled by an owner. The owner can be a smart contract or an external account. This standard requires ERC173 and should implement the functions:

• owner() view
• transferOwnership(address newOwner)
  

The event:

• OwnershipTransferred(address indexed previousOwner, address indexed newOwner)

Data keys

Data keys, should be the keccak256 hash of a type name. e.g. keccak256('ERCXXXMyNewKeyType') is 0x6935a24ea384927f250ee0b954ed498cd9203fc5d2bf95c735e52e6ca675e047

The ERC725JSONSchema standard defines how keys should be named and generated. This JSON schema can be used to auto decode ERC725Y values from smart contracts for application and smart contract interactions.

Default key values

ERC725 key standards need to be defined within new standards, we suggest the following defaults:

ERC725Account

The specification of an ERC725Account can be found in LSP0-ERC725Account.

Rationale

The purpose of an smart contract account is to allow an entity to exist as a first-class citizen with the ability to execute arbitrary contract calls.

Implementation

• Latest implementation

Solidity Interfaces

// SPDX-License-Identifier: CC0-1.0
pragma solidity >=0.5.0 <0.7.0;

//ERC165 identifier: `0x44c028fe`
interface IERC725X  /* is ERC165, ERC173 */ {
    event ContractCreated(uint256 indexed operation, address indexed contractAddress, uint256 indexed value);
    event Executed(uint256 indexed operation, address indexed to, uint256 indexed  value, bytes data);

    function execute(uint256 operationType, address to, uint256 value, bytes calldata data) external payable returns(bytes memory);
}

//ERC165 identifier: `0x5a988c0f`
interface IERC725Y /* is ERC165, ERC173 */ {
    event DataChanged(bytes32 indexed key, bytes value);

    function getData(bytes32[] memory _keys) external view returns(bytes[] memory);
    function setData(bytes32[] memory _keys, bytes[] memory _values) external;
}

interface IERC725 /* is IERC725X, IERC725Y */ {

}

Flow chart

Additional References

• Slides of the ERC Identity presentation
• In-contract claim VS claim registry
• Identity related reports
• W3C Verifiable Claims Use Cases
• Decentralised Identity Foundation
• Sovrin Foundation Self Sovereign Identity

Copyright

Copyright and related rights waived via CC0.

Citation

Please cite this document as:

Fabian Vogelsteller, Tyler Yasaka, "EIP-725: General key-value store and execution standard [DRAFT]," Ethereum Improvement Proposals, no. 725, October 2017. [Online serial]. Available: https://eips.ethereum.org/EIPS/eip-725.