Ethereum: EIP-3448 really need the metadata length or is it optional?

Ethereum: EIP-3448’s Metadata Length – Is It Mandatory or Optional?

Ethereum’s EIP-3448 specification has been a topic of discussion among developers and researchers for some time. One of the key aspects of this standard is the metadata length, which is indicated by the last 32 bytes (one word) of the bytecode. However, as we delve deeper into the specifications, it becomes clear that the metadata length requirement might not be entirely mandatory.

The Specification

EIP-3448 is a self-executing contract on the Ethereum blockchain that allows developers to create custom smart contracts. The specification outlines several important aspects of this new standard, including:

• Metadata Length: As mentioned earlier, the last 32 bytes (one word) of the bytecode must indicate the length of the metadata in bytes.

• Type Definitions: EIP-3448 defines two type definitions: 0x00 and 0x01. These types represent metadata that can be included at any point in the bytecode.

Optional or Mandatory?

At first glance, it seems like the metadata length is a mandatory requirement. However, upon closer inspection of the specification, we can see that there are some nuances to consider:

• Default Value

  : According to EIP-3448, if no value is provided for the metadataLength parameter, it defaults to 0 bytes.

• Metadata Types

  : The specification also allows metadata types to be included at any point in the bytecode, regardless of their length.

• Custom Implementations: Some developers have implemented custom implementations that do not require the metadata length to be specified.

Conclusion

In conclusion, while the metadata length is a mandatory requirement as stated by EIP-3448, it is not strictly necessary to include this information in the bytecode. Developers who choose to implement custom metadata types or rely on default values are free to ignore this aspect of the specification. However, for developers who require strict adherence to this standard, it may be worth including a metadataLength parameter.

Example Code

Here’s an example of how you might implement EIP-3448 in Solidity:

pragma solidity ^0.8.0;


contract MetadataExample {

    // metadata length is 64 bytes by default

    uint256 metadataLength = 64;


    function setMetadata() public {

        // include the metadata type and value

        metadataType := 0x01;

        uint256 metadataValue = 0x1234567890abcdef;

        // ...

    }

}

In this example, the metadataLength parameter is not included in the bytecode. Instead, we rely on default values to set our metadata.

Conclusion

EIP-3448 is an important standard for smart contracts on the Ethereum blockchain. While the metadata length is a mandatory requirement, it’s essential to consider the nuances of this specification and whether custom implementations are necessary for your use case. By including a metadataLength parameter or relying on default values, developers can ensure that their code adheres to EIP-3448 standards while also meeting their specific requirements.

ethereum where transactions confirmed stored