This article is from: Ethereum developer levochka.eth
Compiled by | Odaily ([@OdailyChina](https://x.com/OdailyChina)); Translator | Azuma (translator ([@azuZuma_eth](https://x.com/azuma_eth))
Yesterday, Ethereum co-founder Vitalik published a radical article about Ethereum execution layer upgrades (see 《Vitalik's Radical New Article: Execution Layer Scaling "Break to Rebuild", EVM Must Be Iterated in the Future》), mentioning hopes to replace EVM with RISC-V as the virtual machine language for smart contracts.
As soon as the article was published, it immediately stirred up a huge wave in the Ethereum developer community, with many technical experts expressing different views. Shortly after the article was published, a first-line Ethereum developer levochka.eth wrote a long article under the original text to refute Vitalik's viewpoint, believing that Vitalik made incorrect premise assumptions about the proof system and its performance, and that RISC-V cannot take into account both "scalability" and "maintainability", and may not be the best choice.
The following is the original content by levochka.eth, compiled by Odaily.
As I understand, the main argument of the the is scalability" maint.
First, I want to discuss maintainability.
In fact, all RISC-V zk-VM must use "precompiles" to handle computationally intensive operations. The precompile list of SP 1 can be found in the in a href docs.inct.xyz/docs/sp11/writing-programs//pre-comprel="low">inct Succinct,>, and you will find it almost covers all important "computational" opcodes in the EVM.
Therefore, <
Indeed, if performance is good enough, the maintainability of the "non-EVM" part in the execution client may be relatively easy. I am not sure if performance will be good but I have low confidence in this part for the following reasons:
"State tree computation" can indeed be significantly accelerated by friendly precompiles (such as Poseidon).
But it is unclear whether "deserialization" can be handled in an elegant and maintainable manner.
In addition, there are some tricky details (such as and measurement and various checks) that may belong to "block evaluation time", but in fact should be classified as "non-EVM" part, and these parts are often more prone to maintenance pressure.
Secondly, regarding the scalability part.
I need to reiterate that, RISC-V absolutely cannot handle the EVM load without using precompiles.
So, - it assumes that there will be no precompiles in but in fact ((in this future scenario precompiles will still exist and be completely completely consistent with computationally intensive opcodes in the> the EVM,VM (such as signatures, hashes, and possibly large modular arithmetic).
Regarding the "Fibonacci" example, it is difficult to make a judgment without delving into extremely low-level details, but its advantages come at least partially from:
The difference between "" "overhead";
Loop unrolling (reducing RISC-V's "control flow", it is uncertain whether Solidity can achieve this, but even individual opcodes will still generate a lot of control flow/memory access due to interpretation overhead);
Using smaller data types;
Here I want to point to achieve first and second advantages, the "interpretation overhead""" be eliminated. This is consistent with the THE riV philosophy, but this is not the RISC-V we are currently with discussing, but rather a similar "(?)" RISC-V —— it needs to have some additional capabilities, such as supporting the contract concept.
Problems Arise
h2> p, are some problems here.To improve maintmaintainability, you need a RISC-V that can compile EVM (with precompiles) - which is basically the current situation.
<**To improve scalability, you need something completely different - a new new similar to riV that can understand the "contract-" concept, be compatible with Ethereum runtime constraints, and directly execute contract code (without "interpretation overhead").
I now assume you are referring to the case (because the of seems to suggest this). I need to remind you that all code outside this environment will still be in the CURRENT RIRISC-V zkVM language, which which has a major impact on maintenance.
Other Possibilities
We can compile bytecode from high-level EVM opcodes. The compiler is responsible for ensuringing that the generated program maintains invariants, such as not causing "stack overflow". I hope to see this demonstrated in a normal EVM. A correctly compiled SNARK can be provided along with contract deployment instructions.
We can also construct a "formal proof" to prove that certain invariants are preserved. To my knowledge, this method (rather than "virtualization") has been used in some browser contexts. By generating a SNARK of such a formal proof, you can also achieve similar results.
Of course, the simplest option is to grit your teeth and do it...
p>You have implied this in your article article article, but please allow let me me remind you: To eliminate virtualization overhead, you compiled code this means you need to prevent contracts (now executable programs) writing into kernel (non-EVM implementation) memory in some way. >At this point, the provable EEVM will become the kernel program running on this architecture.RISC-V May Not Be the Best Choice h Best Option
Interestingly, under all these conditions, the best "instruction set architecture" (ISA) for this task may not NOT be RISC-V, but something similar to EOF to EOF-E>,V, for the following reasons:>
