By standardizing on a known minimal bytecode proxy implementation with support for immutable metadata, this standard allows users and third party tools (e.g. Etherscan) to: (a) simply discover that a contract will always redirect in a known manner and (b) depend on the behavior of the code at the destination contract as the behavior of the redirecting contract and (c) verify/view the attached metadata.
Tooling can interrogate the bytecode at a redirecting address to determine the location of the code that will run along with the associated metadata - and can depend on representations about that code (verified source, third-party audits, etc).
This implementation forwards all calls via DELEGATECALL and any (calldata) input plus the metadata at the end of the bytecode to the implementation contract and then relays the return value back to the caller.
In the case where the implementation reverts, the revert is passed back along with the payload data.
This standard supports use-cases wherein it is desirable to clone exact contract functionality with different parameters at another address.
The exact bytecode of the MetaProxy contract is:
wherein the bytes at indices 21 - 41 (inclusive) are replaced with the 20 byte address of the master functionality contract. Additionally, everything after the MetaProxy bytecode can be arbitrary metadata and the last 32 bytes (one word) of the bytecode must indicate the length of the metadata in bytes.
The goals of this effort have been the following:
There are no backwards compatibility issues.
Tested with:
A solidity contract with the above test cases can be found in the EIP asset directory.
A reference implementation can be found in the EIP asset directory.
A annotated version of the deploy bytecode:
A annotated version of the MetaProxy bytecode:
The following code snippets serve only as suggestions and are not a discrete part of this standard.
Apart from the examples above, it is also possible to use Solidity Structures or any custom data encoding.
This standard only covers the bytecode implementation and does not include any serious side effects of itself. The reference implementation only serves as a example. It is highly recommended to research side effects depending on how the functionality is used and implemented in any project.
Copyright and related rights waived via CC0.