###### tags: `Technical Notes` # Initial syntax for explicit storage locations This specification is the minimal version of variant 2 from [Syntax proposal for explicit storage locations](https://notes.ethereum.org/@solidity/explicit-storage-layout-syntax). The intention is to eventually extend the feature to introduce the full range of options from that variant. ## Specification ### Syntax and semantics ```bnf layout-specification ::= "layout" "at" <base-slot-expression> ``` Where: 1. `layout-specification` can only appear in the header of a contract definition. It can appear at any position between the name of the contract and the opening brace of the body, i.e. either before or after the inheritance specifier. It can be given at most once. 1. `base-slot-expression` is an expression that can be evaluated at compilation time and yields a value in the `uint256` range. As a general rule, any expression that can be used to specify the size of an array may also be used to indicate a slot. Currently this includes operations on literals and the newly introduced `erc7201()` helper. 1. `layout` and `at` will become global keywords in the next breaking release. Until then they can still be freely used as identifiers, but it is strongly recommended to avoid using them as contract names. When the extended layout syntax is introduced later, it may be unusable with such contracts. 1. Layout cannot be specified for interfaces, libraries and abstract contracts. 1. Layout can only be specified in the most derived contract. 1. `base-slot-expression` determines the starting storage location for the inheritance hierarchy as a whole. Locations of all storage variables are shifted by its value and their locations relative to each other remain unaffected. 1. The layout of a contract without an explicit specification is identical to one with `layout at 0`. ### `erc7201()` helper A new global function is introduced, based on the `erc7201` formula from [ERC-7201](https://eips.ethereum.org/EIPS/eip-7201), with behavior equivalent to: ```solidity function erc7201(bytes memory id) pure returns (uint256) { return uint256( keccak256(bytes.concat(bytes32(uint256(keccak256(id)) - 1))) & ~bytes32(uint256(0xff)) ); } ``` The new function is always evaluated at compilation time and may only be called with arguments whose values are compile-time constants as well. Note that: - The function is not limited to layout definitions. It can be used in arbitrary expressions anywhere in the code. - `erc7201` is not a keyword. The name can be shadowed just like any other global function. ### Examples ```solidity contract FinalContract is BaseA, BaseB(42), BaseC layout at erc7201("example.main") {} ``` ```solidity uint constant X = 42; contract A { uint x; } contract B { address payable y; mapping (address => bool) public map; } contract C is A, B layout at 0x1234 { bool flag; } contract D layout at erc7201("D") is A, B {} contract E layout at 0xffff * (50 - X) { uint y; } ```