Support cours Ethereum Virtual Machine
Ceci est un support de cours sur l’EVM (Ethereum Virtual Machine) pour le cours de l’Ecole Supérieure d’Ingénieurs Léonard de Vinci (ESILV).
Il comprend du matériel de cours, des illustrations et des liens vers des ressources.
La durée du cours est de 3h, séparé en une lesson de 1h15 et des travaux dirigés de 1h15. La première partie est une introduction à la machine de Turing et sa correspondance aux processeurs de nos jours (rappel des connaissances), la seconde partie est une introduction à l’EVM et sa correspondance avec la machine de Turing.
Les travaux pratiques consistent à observer le fonctionnement de l’EVM ainsi que la lecture des opcodes au travers du debugger Remix et à implémenter des opcodes directement dans un second temps.
NB: Tenderly peut-être utilisé pour une meilleure observervation du fonctionnement de l’EVM sur la blockchain Ethereum mais est un peu plus long à mettre en place.
Machine de Turing⌗
Machine de Turing https://www.youtube.com/watch?v=L5O04P2ASRc&t=647s
Ethereum Virtual Machine (EVM)⌗
Lexiques https://github.com/asseth/yellowpaper/blob/7dd3ed26b6fe4b7a1b0394194ef268d01f9955b4/Paper.pdf Page 17
Dive in http://takenobu-hs.github.io/downloads/ethereum_evm_illustrated.pdf
Illustration⌗
- Illustration Turing machine => https://medium.com/creative-automata/classic-turing-machine-with-tape-erasure-e14870ad154e
- http://takenobu-hs.github.io/downloads/ethereum_evm_illustrated.pdf
Bibliography⌗
-
Execution model Page 56
Implementation⌗
Travaux dirigés⌗
Solidity sources to analyze:
- Goal, observe the behavior of the EVM between the differents implementation functions of the same algorithm:
- Sum of an array of uint.
// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.4.16 <0.9.0;
library VectorSum {
// This function is less efficient because the optimizer currently fails to
// remove the bounds checks in array access.
function sumSolidity(uint[] memory data) public pure returns (uint sum) {
for (uint i = 0; i < data.length; ++i)
sum += data[i];
}
// We know that we only access the array in bounds, so we can avoid the check.
// 0x20 needs to be added to an array because the first slot contains the
// array length.
function sumAsm(uint[] memory data) public pure returns (uint sum) {
for (uint i = 0; i < data.length; ++i) {
assembly {
sum := add(sum, mload(add(add(data, 0x20), mul(i, 0x20))))
}
}
}
// Same as above, but accomplish the entire code within inline assembly.
function sumPureAsm(uint[] memory data) public pure returns (uint sum) {
assembly {
// Load the length (first 32 bytes)
let len := mload(data)
// Skip over the length field.
//
// Keep temporary variable so it can be incremented in place.
//
// NOTE: incrementing data would result in an unusable
// data variable after this assembly block
let dataElementLocation := add(data, 0x20)
// Iterate until the bound is not met.
for
{ let end := add(dataElementLocation, mul(len, 0x20)) }
lt(dataElementLocation, end)
{ data := add(dataElementLocation, 0x20) }
{
sum := add(sum, mload(dataElementLocation))
}
}
}
}