What are the improvements in the new version of the smart contract language Solidity?

Author: Adam Boudjemaa

Compiler: Mr. Huai, Director of the Investment Research Department of the Web3 Club of Wuhan University

Introduction

After an extensive analysis of information such as the Solidity Github repository, the Solidity roadmap, community conversations on Twitter, active Pull Requests, and Issues, this article takes a deep dive into where the future of Solidity is headed.

The leading smart contract programming language is about to be released with 0.9.0 and 1.0.0 upgrades, which will introduce several highly anticipated enhancements.

The purpose of this article is to introduce readers to the latest developments and improvements in Solidity, which are based on community input and ongoing debates. While the relevant information provided is inconclusive, it reveals potential directions for technological advancement.

1. Revolutionary integration of require() with Custom Error

Current method (0.8.x):

Expected to occur at 0.9.0 or 1.0.0:

Rather than using a large number of if conditions to throw an error with string information or a custom error, using a combination of require() and custom error will make the program clearer and save gas.

2. Internal Representation (IR) Optimization: Release Efficiency

The internal representation (IR) process in Solidity plays a key role in converting smart contract source code into executable instructions for the ETH Virtual Machine (EVM).

Internal representation streamlines and standardizes complex code, making the process of converting code into machine language more efficient. Solidity’s upcoming improvements to 0.9.0 are designed to make this compilation process faster and more efficient, ultimately reducing costs and increasing developer productivity.

3. Enhanced error handling: Clarification and simplification of code

It is expected that future updates will enhance error handling in Solidity, resulting in more straightforward error messages and easier debugging.

This enhancement is especially useful for developers working with complex contracts, saving time and minimizing potential errors.

4. Fixed-point arithmetic: high precision and high performance

[Translator’s note: A fixed-point number is a data type used by computers to represent decimal numbers corresponding to floating-point numbers, and its integer digits and decimal places are fixed values, so they are more secure than floating-point numbers.] At present, Solidity does not have any built-in data types that represent decimals, and developers often need to multiply the original data by a large number to manually reserve decimal places, and keep an eye on the decimal point problem in subsequent operations, which is quite troublesome. 】

At this stage, external libraries such as ABDKMath64x64 and DSMath use Solidity to implement fixed-point numbers.

The 0.9.0 update is expected to integrate native fixed-point arithmetic and no longer require external libraries. This will make decimal calculations much more simplified.

5. EVM Object Format (EOF): Build smart contract bytecode

Solidity’s upcoming EOF upgrade prepares to introduce structured and versioned bytecode for smart contracts.

This improvement is expected to make future contract updates easier to implement, maintain backward compatibility, and enable more efficient analysis during the compilation phase.

While this won’t change the direct coding experience for smart contract developers, the compiler’s output will be more gas-efficient.

6. Transient Storage: Ad-hoc and efficient data processing

Solidity’s new feature, Transient Storage, proposes a way to temporarily save data during contract execution without permanently recording it on the blockchain. This approach is expected to be more efficient in terms of gas consumption.

Transient storage similar to the code below is likely to be found in Solidity 0.9.0 or Solidity 1.0.0.

7. Natively integrated re-entrancy protection

Prior to version 0.8.0, the SafeMath library was a common tool used by developers for arithmetic operations to avoid overflow and lower limit overflow problems. With the release of Solidity 0.8.0, these security checks are embedded directly into the language.

Similarly, Solidity version 0.9.0 or 1.0.0 is expected to natively integrate re-entrancy protection. This feature is designed to simplify the process of implementing security protocols to prevent re-entrancy attacks.

You’ll see something like this:

8. Refactored inheritance and storage layouts

In Solidity, inheritance creates a new contract that takes on the properties and functionality of an existing contract. The planned update aims to improve the linearization of inheritance and storage layouts, thereby enhancing the predictability and organization of the contract architecture. This can improve storage usage efficiency and reduce confusion in multi-inheritance scenarios.

For example, a contract Child that inherits from ParentA and ParentB will have an optimized storage layout and continuous variable storage, reducing the cost of storage operations.

9. Enhanced compilation flags and configuration options

The development of Solidity includes extending the scope of compilation flags and configuration settings, providing developers with a high degree of control over the compilation process. These enhancements may lead to more customized contract deployments with fine-grained control over gas optimization, security checks, and debugging capabilities.

New compilation flags can allow developers to toggle specific optimizations or security checks:

For example, a new compilation flag, --enable-loop-optimization, will focus on optimizing loops to improve gas efficiency, and a new compilation flag, --strict-security-checks, will introduce harsh security analysis during compilation

10. Improved debugging tools and error messages

The enhanced debugging tool has more detailed error messages and can significantly simplify the development process, especially for complex contract structures. Improved error messages can help developers better understand problems in their code, and advanced debugging tools can help developers find and fix problems more effectively.

11. Support for advanced data types and structures

Introducing complex data types and structures in Solidity can inspire new contract design and functional possibilities. This may include supporting more complex numeric types, enhanced data structures, or improved methods for handling large data sets in contracts.

Solidity may introduce a new data structure, such as TreeMap, which organizes data in a sorted way for efficient retrieval. This can be useful in contracts where data needs to be sorted or sorted, such as in voting systems. [Translator’s note: Similar to the red and black tree.] Another advancement could be to support more complex types of numbers, such as fixed-point numbers, which can perform precise mathematical operations directly in the contract.

12. Introducing generics and templates

Generics and templates in Solidity will make more adaptable and reusable code possible. For example, you can create a generic function to handle different types of assets (such as ERC20 tokens, NFTs, etc.) in a standardized way without having to rewrite the function for each specific asset type. This will improve contract design and development efficiency, as a single function can be applied to a variety of scenarios.

Future Prospects: The Road to Solidity 1.0.0

On various platforms such as Github, Twitter, Ethresearch, and Reddit, there is a lot of discussion within the Solidity community about the development of the 0.9.0 release.

A focal point of debate is unveiling:

Is it a straightforward and cautious transition to Solidity 1.0.0 to declare the full maturity of the language, or is it a gradual progression to a more advanced version with the 0.9.0 release first?

Influenced by community feedback and creative ideas, the expected debut of Solidity 1.0.0 is likely to coincide with a major update for ETH Workshop, reflecting the growth and stability of the ecosystem as a whole.

1. The Evolution of Type Systems: Improving Flexibility and Security. It is expected that there will be an upgrade-type system that draws inspiration from functional programming languages such as Haskell or Scala. This evolution aims to increase the security and flexibility of contract development.

2. Integrated native oracle support: Simplify external data interactions. Plans include integrating built-in support for decentralized oracles in Solidity, facilitating more secure and direct interactions with external data sources.

3. Improve state management: Improve blockchain interaction. Enhancements to state management capabilities are being discussed, and elements such as state channels or sidechains may be introduced as built-in structures designed to optimize interactions on the blockchain and reduce gas fees.

4. Modular approach to contract design: improve reusability. A shift to a modular contract architecture is being envisaged, allowing the use of replaceable components. This significantly simplifies the development process and improves the operability of the code.

5. Integrate formal verification tools: ensure contract reliability. There is an expectation that formal verification tools will be integrated directly into Solidity, a move that aims to ensure that contracts comply with specific standards and behaviors, thereby reducing the likelihood of errors and vulnerabilities.

6. Build cross-chain capabilities: Achieve cross-blockchain interoperability. Future updates may introduce native cross-chain compatibility features, allowing Solidity contracts to run smoothly across a variety of blockchain protocols.

7. Implement advanced privacy measures: Enhance data security. Plans are underway to integrate advanced privacy tools, such as zero-knowledge proofs or homomorphic encryption, directly into the language to enhance data security and user privacy.

8. Quantum-Resistant Cryptography: Preparing for Future Challenges. Given the emerging quantum computing capabilities, people are considering implementing quantum-resistant cryptography methods to protect ETH contracts from potential future threats.

Conclusion

As you explore potential paths to Solidity, this article combines community insights and current developments with community projections to give you a comprehensive understanding of the topic. While we’ve delved into the possibilities of versions 0.9.0 and 1.0.0, the actual trajectory and feature set is subject to change as Solidity continues its development journey. Stay tuned to see how these conversations and concepts come to life in the ever-evolving world of smart contract programming.