EIPs

EIP725 - 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)
1

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);
1

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);
1

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)
1

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
1

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)
1

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 (opens new window) 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 (opens new window) 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:

Name Description Key value
SupportedStandards:XYZ Allows to determine standards supported by this contract 0xeafec4d89fa9619884b6b89135626455000000000000000000000000xxxxxxxx, where xxxxxxxx is the 4 bytes identifier of the standard supported Value can be defined by the standard, by default it should be the 4 bytes identifier e.g. 0x7a30e6fc
SupportedStandards:ERC725Account Allows to determine standards supported by this contract 0xeafec4d89fa9619884b6b89135626455000000000000000000000000afdeb5d6, where afdeb5d6 is the 4 bytes part of the hash of keccak256('ERC725Account') Value is the 4 bytes identifier 0xafdeb5d6

# ERC725Account

The specification of an ERC725Account can be found in LSP0-ERC725Account (opens new window).

# 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

# 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 */ {

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

# Flow chart

ERC725v2-flow

# Additional References

Copyright and related rights waived via CC0 (opens new window).

▲ Powered by Vercel