Blockchain Computer of Ethereum
ECE598PV Lecture 20
Blockchain Computer of
Ethereum
Instructor: Prof. Pramod Viswanath
Lecture by
Gerui Wang
April 6, 2021
Order-Execute Structure
Order-Execute Structure
Persistent state storage (state db)
In the state of a payment system, account information includes:
●
address: identification
●
account-nonce: integer
●
balance: integer
In smart contract system like Ethereum,
●
address: identification
●
account-nonce: integer
●
balance: integer
●
code: a sequence of OPCODEs
●
account storage: <key: U256, value: U256>
Persistent state storage (state db)
Hash Accumulator (Merkle Patricia Trie)
to compute the state root.
State root
Persistent state storage (state db)
State root in
Block 1
State root in
Block 2
Creation of a contract
●
account-nonce: 0
●
balance: the value you payed (usually 0)
●
code: the OPCODEs you wrote
(explained later)
●
account storage: empty
●
address: hash of your information and code.
What is OPCODEs and how to write them?
Order-Execute Structure
EVM OPCODE vs Solidity
Ethereum Virtual Machine Operation
Code (EVM OPCODE)
●
Low level
●
Stack-based language
●
Similar to Machine
Code/Assembly
Usually people write contracts in high
level language like Solidity and
compile them to OPCODE.
Solidity
●
High level
●
Solidity can be compiled to
OPCODE
●
Similar to C++, Java, etc.
OPCODE
OPCODE is identified by a byte (00 - FF).
This is the current OPCODE in use.
A
r
i
t
h
m
e
t
i
c
O
p
e
r
a
t
i
o
n
s
C
o
m
p
a
r
i
s
o
n
&
B
i
t
w
i
s
e
L
o
g
i
c
O
p
e
r
a
t
i
o
n
s
K
e
c
c
a
k
-
2
5
6
h
a
s
h
E
n
v
i
r
o
n
m
e
n
t
a
l
I
n
f
o
r
m
a
t
i
o
n
B
l
o
c
k
I
n
f
o
r
m
a
t
i
o
n
S
t
a
c
k
,
M
e
m
o
r
y
,
S
t
o
r
a
g
e
a
n
d
F
l
o
w
O
p
e
r
a
t
i
o
n
s
P
u
s
h
O
p
e
r
a
t
i
o
n
s
D
u
p
l
i
c
a
t
i
o
n
O
p
e
r
a
t
i
o
n
s
E
x
c
h
a
n
g
e
O
p
e
r
a
t
i
o
n
s
L
o
g
g
i
n
g
O
p
e
r
a
t
i
o
n
s
S
y
s
t
e
m
o
p
e
r
a
t
i
o
n
s
Stack-based language
During the execution, EVM keeps a (first in last out) stack. Stack item unit size is
256 bits (32 bytes). Stack maximum capacity is 1024.
OPCODEs insert/remove items to/from the stack.
Volatile, deleted after execution.
Example
PUSH1 0x01
(push 0x01 and padding 0’s)
PUSH1 0x02
ADD
(add first & second item and
push result in)
Memory
An array of bytes, addressed by an U256. Item unit size is one byte.
OPCODEs read/write the memory.
Volatile, deleted after execution.
Storage
Key value storage. Key, value both 32 bytes.
OPCODEs read/write the storage.
Persistent.
Maintained in a hash accumulator.
Stack vs Memory vs Storage
Storage (persistent)
Stack (volatile)
Memory (volatile)
What happens to Stack, Memory, Storage at
execution?
Storage
S
t
a
t
e
D
B
Stack
Memory
Initialize a new instance of
Stack & Memory
What happens to Stack, Memory, Storage at
execution?
Storage
S
t
a
t
e
D
B
Stack
Memory
As contract runs, they are
read/written...
As contract runs, storage
is read/written...
What happens to Stack, Memory, Storage at
execution?
Storage
S
t
a
t
e
D
B
Stack
Memory
After exectuion
PC, contract, transaction, caller, etc information
Storage (persistent)
Stack (volatile)
Memory (volatile)
EVM initializes a program counter (pc: U256) pointing to the OPCODE to be
executed, and increments as the contract runs.
EVM also requires information such as contract address, balance, transaction gas
capacity, caller address, transaction call data, etc.
Example of executing OPCODE (not executing
contract!)
Example OPCODE sequence:
PUSH1 0x01
PUSH1 0x02
ADD
PUSH1 0x00
MSTORE
PUSH1 0x20
PUSH1 0x00
RETURN
Stack
Memory
PC
Example of executing OPCODE (not executing
contract!)
Example OPCODE sequence:
PUSH1 0x01
PUSH1 0x02
ADD
PUSH1 0x00
MSTORE
PUSH1 0x20
PUSH1 0x00
RETURN
Stack
Memory
PC
Example of executing OPCODE (not executing
contract!)
Example OPCODE sequence:
PUSH1 0x01
PUSH1 0x02
ADD
PUSH1 0x00
MSTORE
PUSH1 0x20
PUSH1 0x00
RETURN
Stack
Memory
PC
Example of executing OPCODE (not executing
contract!)
Example OPCODE sequence:
PUSH1 0x01
PUSH1 0x02
ADD
PUSH1 0x00
MSTORE
PUSH1 0x20
PUSH1 0x00
RETURN
Stack
Memory
PC
Example of executing OPCODE (not executing
contract!)
Example OPCODE sequence:
PUSH1 0x01
PUSH1 0x02
ADD
PUSH1 0x00
MSTORE
PUSH1 0x20
PUSH1 0x00
RETURN
Stack
Memory
PC
Example of executing OPCODE (not executing
contract!)
Example OPCODE sequence:
PUSH1 0x01
PUSH1 0x02
ADD
PUSH1 0x00
MSTORE
PUSH1 0x20
PUSH1 0x00
RETURN
Stack
Memory
PC
Store value 0x00...03
to address 0x00...00
(to 32 bytes after)
32
bytes
Example of executing OPCODE (not executing
contract!)
Example OPCODE sequence:
PUSH1 0x01
PUSH1 0x02
ADD
PUSH1 0x00
MSTORE
PUSH1 0x20
PUSH1 0x00
RETURN
Stack
Memory
PC
32
bytes
Example of executing OPCODE (not executing
contract!)
Example OPCODE sequence:
PUSH1 0x01
PUSH1 0x02
ADD
PUSH1 0x00
MSTORE
PUSH1 0x20
PUSH1 0x00
RETURN
Stack
Memory
PC
32
bytes
Example of executing OPCODE (not executing
contract!)
Example OPCODE sequence:
PUSH1 0x01
PUSH1 0x02
ADD
PUSH1 0x00
MSTORE
PUSH1 0x20
PUSH1 0x00
RETURN
Stack
Memory
PC
32
bytes
Return value in
memory from address
0x00...00 to address
0x00...20
Example of executing OPCODE (not executing
contract!)
Example OPCODE sequence:
PUSH1 0x01
PUSH1 0x02
ADD
PUSH1 0x00
MSTORE
PUSH1 0x20
PUSH1 0x00
RETURN
Stack
Memory
PC
32
bytes
Return 0x00...03.
End of execution.
Example of executing OPCODE (not executing
contract!)
Example OPCODE sequence:
PUSH1 0x01
PUSH1 0x02
ADD
PUSH1 0x00
MSTORE
PUSH1 0x20
PUSH1 0x00
RETURN
Stack
Memory
PC
32
bytes
Return 0x00...03.
End of execution.
Try download and compile Open Ethereum evmbin package, and run
./target/release/openethereum-evm stats --code
600160020160005260206000f3
You will see output
0x00000000000000000000000000000000000000000000000000000000000
00003
Creation of a contract
Y
o
u
c
a
n
c
r
e
a
t
e
a
c
o
n
t
r
a
c
t
b
y
a
t
r
a
n
s
a
c
t
i
o
n
.
Y
o
u
p
r
o
v
i
d
e
t
h
e
i
n
i
t
i
a
l
i
z
a
t
i
o
n
O
P
C
O
D
E
,
w
h
i
c
h
i
s
u
s
u
a
l
l
y
p
r
o
v
i
d
e
d
b
y
S
o
l
i
d
i
t
y
c
o
m
p
i
l
e
r
.
Example:
Initialization OPCODE:
Creation of a contract
The initialization OPCODE basically does one thing: store the highlighted
OPCODE into the newly created contract.
Creation of a contract
Now the contract is created:
●
account-nonce: 0
●
balance: the value you payed (usually 0)
●
code:
●
account storage: empty
●
address: hash of your information and code.
Calling/executing a contract
Now any address can call this contract with the contract address.
One can call this contract by providing:
●
contract address
●
call data
●
gas fee (similar to transaction fee in Bitcoin)
in a transaction.
Calling/executing a contract
Example:
●
contract address: the address just created
●
call data:
0x448f30a3
●
gas fee: doesn’t matter
in private experiment
Hash of this
function.
Storage
S
t
a
t
e
D
B
Stack
Memory
call data:
0x448f30a3
OPCODE:
How does contract know which function in a contract?
In the OPCODE, this sequence checks which function:
CALLDATALOAD … PUSH4 0x448f30a3 EQ
Stack
call data:
0x448f30a3
How does contract know which function in a contract?
In the OPCODE, this sequence checks which function:
CALLDATALOAD … PUSH4 0x448f30a3 EQ
Call data is loaded into stack. (And do padding.)
Stack
call data:
0x448f30a3
How does contract know which function in a contract?
In the OPCODE, this sequence checks which function:
CALLDATALOAD … PUSH4 0x448f30a3 EQ
Push 0x448f30a3 into stack.
Stack
call data:
0x448f30a3
How does contract know which function in a contract?
In the OPCODE, this sequence checks which function:
CALLDATALOAD … PUSH4 0x448f30a3 EQ
Check whether two items are equal (answer is yes).
With “yes”, the contract can execute OPCODE that is for this function.
Stack
call data:
0x448f30a3
Features of OPCODE
There are OPCODEs that call other contracts, create new contracts, thus enabling
recursion.
There are JUMP that controls pc, thus enabling if/else, for semantics in high-level
languages.
Gas fee
Starting point: prevent someone writes and runs an infinite loop.
G
a
s
c
a
p
:
t
h
e
m
a
x
i
m
u
m
g
a
s
t
h
i
s
t
r
a
n
s
a
c
t
i
o
n
c
a
n
u
s
e
.
G
a
s
u
s
a
g
e
:
t
h
e
g
a
s
f
e
e
i
n
c
u
r
r
e
d
b
y
e
x
e
c
u
t
i
n
g
O
P
C
O
D
E
s
a
n
d
o
t
h
e
r
o
p
e
r
a
t
i
o
n
s
.
●
Memory fee increases quadratically with usage.
●
Storage fee is much heavier than memory fee.
●
Base fee that every tx pays.
If gas usage > gas cap, execution aborted.
G
a
s
p
r
i
c
e
:
d
e
c
i
d
e
d
b
y
c
a
l
l
e
r
/
s
e
n
d
e
r
.
A
c
t
u
a
l
f
e
e
=
g
a
s
u
s
a
g
e
*
g
a
s
p
r
i
c
e
.
Gas fee
However, gas fee rule is not a perfect measurement for the cost of running
contracts and has changed many times. (E.g., some OPCODE may have too
high/low gas fee.)
How about payment to users?
Two types of account:
U
s
e
r
account-nonce
balance
code: empty all the time
account storage: empty all the time
address: hash of your public key.
You holds a key pair.
C
o
n
t
r
a
c
t
account-nonce: 0 all the time
balance: usually 0 all the time
code: OPCODE
account storage: read/write from code
address: hash of creator’s address and
code.
No key pair.
How about payment to users?
Two types of transaction:
P
a
y
t
o
U
s
e
r
receiver: the user
value
gas capacity: set by sender
gas price: set by sender
call data: empty
The gas fee is a small constant.
C
a
l
l
a
C
o
n
t
r
a
c
t
receiver: the contract
value: usually 0
gas capacity: set by sender
gas price: set by sender
call data: the function and parameters, set
by sender
The gas fee depends on the contract.
How about payment to users?
Two types of transaction:
P
a
y
t
o
U
s
e
r
receiver: the user
value
gas capacity: set by sender
gas price: set by sender
call data: empty
The gas fee is a small constant.
C
a
l
l
a
C
o
n
t
r
a
c
t
receiver: the contract
value: usually 0
gas capacity: set by sender
gas price: set by sender
call data: the function and parameters, set
by sender
The gas fee depends on the contract.
A
l
s
o
t
h
e
r
e
i
s
C
r
e
a
t
e
a
C
o
n
t
r
a
c
t
t
r
a
n
s
a
c
t
i
o
n
,
w
h
i
c
h
i
s
d
i
f
f
e
r
e
n
t
f
r
o
m
t
h
e
s
e
t
w
o
.
How does this fit into a
blockchain client?
Virtual Machine Environment:
Stack, memory, pc, etc.
References
Ethereum Yellow Book
Solidity website
https://ethervm.io/decompile
Q&A
Explore the intricate workings of Ethereum's blockchain computer, from the order-execute structure to persistent state storage mechanisms. Learn about account information, smart contracts, Merkle Patricia Trie, and the role of OPCODEs in Ethereum Virtual Machine. Delve into the creation of contract accounts and the compilation of high-level Solidity code to low-level OPCODE, providing insight into the fundamental operations and logic used in Ethereum contracts.
Download Presentation
Please find below an Image/Link to download the presentation.
The content on the website is provided AS IS for your information and personal use only. It may not be sold, licensed, or shared on other websites without obtaining consent from the author. Download presentation by click this link. If you encounter any issues during the download, it is possible that the publisher has removed the file from their server.
E N D
Presentation Transcript
ECE598PV Lecture 20 Blockchain Computer of Ethereum Instructor: Prof. Pramod Viswanath Lecture by Gerui Wang April 6, 2021
Persistent state storage (state db) In the state of a payment system, account information includes: address: identification account-nonce: integer balance: integer In smart contract system like Ethereum, address: identification account-nonce: integer balance: integer code: a sequence of OPCODEs account storage: <key: U256, value: U256> Explained later
Persistent state storage (state db) Hash Accumulator (Merkle Patricia Trie) State root to compute the state root.
Persistent state storage (state db) State root in Block 1 State root in Block 2
Creation of a contract account-nonce: 0 balance: the value you payed (usually 0) code: the OPCODEs you wrote (explained later) account storage: empty address: hash of your information and code. What is OPCODEs and how to write them?
EVM OPCODE vs Solidity Ethereum Virtual Machine Operation Code (EVM OPCODE) Solidity High level Solidity can be compiled to OPCODE Similar to C++, Java, etc. Low level Stack-based language Similar to Machine Code/Assembly Usually people write contracts in high level language like Solidity and compile them to OPCODE.
OPCODE OPCODE is identified by a byte (00 - FF). This is the current OPCODE in use.
Arithmetic Operations Comparison & Bitwise Logic Operations Keccak-256 hash Environmental Information Block Information Stack, Memory, Storage and Flow Operations Push Operations Duplication Operations Exchange Operations Logging Operations System operations
Stack-based language During the execution, EVM keeps a (first in last out) stack. Stack item unit size is 256 bits (32 bytes). Stack maximum capacity is 1024. OPCODEs insert/remove items to/from the stack. Volatile, deleted after execution.
Example (empty) 00...01 00...01 00...03 00...02 PUSH1 0x01 (push 0x01 and padding 0 s) PUSH1 0x02 ADD (add first & second item and push result in)
Memory An array of bytes, addressed by an U256. Item unit size is one byte. OPCODEs read/write the memory. Volatile, deleted after execution. Address: 0x00...00 0x00...01 0x00...02 ... 0x05 0x00 0x02 0x00 ...
Storage Key value storage. Key, value both 32 bytes. OPCODEs read/write the storage. Persistent. Maintained in a hash accumulator.
Stack vs Memory vs Storage Stack (volatile) Memory (volatile) Storage (persistent) 32 bytes 1 byte 32 bytes 1 byte ... ...
What happens to Stack, Memory, Storage at execution? Initialize a new instance of Stack & Memory State DB Stack Memory Storage empty empty ... ...
What happens to Stack, Memory, Storage at execution? As contract runs, they are read/written... As contract runs, storage is read/written... State DB Stack Memory Storage 0x00...13 0x14 ... 0x50 ...
What happens to Stack, Memory, Storage at execution? After exectuion State DB Stack Memory Storage empty empty ... ...
PC, contract, transaction, caller, etc information EVM initializes a program counter (pc: U256) pointing to the OPCODE to be executed, and increments as the contract runs. EVM also requires information such as contract address, balance, transaction gas capacity, caller address, transaction call data, etc. Stack (volatile) Memory (volatile) Storage (persistent) 32 bytes 1 byte 32 bytes 1 byte ... ...
Example of executing OPCODE (not executing contract!) Example OPCODE sequence: Stack Memory PUSH1 0x01 PUSH1 0x02 ADD PUSH1 0x00 MSTORE PUSH1 0x20 PUSH1 0x00 RETURN PC empty empty ... ...
Example of executing OPCODE (not executing contract!) Example OPCODE sequence: Stack Memory PUSH1 0x01 PUSH1 0x02 ADD PUSH1 0x00 MSTORE PUSH1 0x20 PUSH1 0x00 RETURN PC 0x00...01 empty ... ...
Example of executing OPCODE (not executing contract!) Example OPCODE sequence: Stack Memory PUSH1 0x01 PUSH1 0x02 ADD PUSH1 0x00 MSTORE PUSH1 0x20 PUSH1 0x00 RETURN PC 0x00...01 empty 0x00...02 ... ...
Example of executing OPCODE (not executing contract!) Example OPCODE sequence: Stack Memory PUSH1 0x01 PUSH1 0x02 ADD PUSH1 0x00 MSTORE PUSH1 0x20 PUSH1 0x00 RETURN 0x00...03 empty PC ... ...
Example of executing OPCODE (not executing contract!) Example OPCODE sequence: Stack Memory PUSH1 0x01 PUSH1 0x02 ADD PUSH1 0x00 MSTORE PUSH1 0x20 PUSH1 0x00 RETURN 0x00...03 empty 0x00...00 PC ... ...
Example of executing OPCODE (not executing contract!) Example OPCODE sequence: Stack Memory PUSH1 0x01 PUSH1 0x02 ADD PUSH1 0x00 MSTORE PUSH1 0x20 PUSH1 0x00 RETURN empty 0x00 ... 32 bytes PC ... 0x03 Store value 0x00...03 to address 0x00...00 (to 32 bytes after)
Example of executing OPCODE (not executing contract!) Example OPCODE sequence: Stack Memory PUSH1 0x01 PUSH1 0x02 ADD PUSH1 0x00 MSTORE PUSH1 0x20 PUSH1 0x00 RETURN 0x00...20 0x00 ... 32 bytes ... PC 0x03
Example of executing OPCODE (not executing contract!) Example OPCODE sequence: Stack Memory PUSH1 0x01 PUSH1 0x02 ADD PUSH1 0x00 MSTORE PUSH1 0x20 PUSH1 0x00 RETURN 0x00...20 0x00 0x00...00 ... 32 bytes ... 0x03 PC
Example of executing OPCODE (not executing contract!) Example OPCODE sequence: Stack Memory PUSH1 0x01 PUSH1 0x02 ADD PUSH1 0x00 MSTORE PUSH1 0x20 PUSH1 0x00 RETURN 0x00...20 0x00 0x00...00 ... 32 bytes ... 0x03 Return value in memory from address 0x00...00 to address 0x00...20 PC
Example of executing OPCODE (not executing contract!) Example OPCODE sequence: Stack Memory PUSH1 0x01 PUSH1 0x02 ADD PUSH1 0x00 MSTORE PUSH1 0x20 PUSH1 0x00 RETURN 0x00...20 0x00 0x00...00 ... 32 bytes ... 0x03 Return 0x00...03. End of execution. PC
Example of executing OPCODE (not executing contract!) Example OPCODE sequence: Try download and compile Open Ethereum evmbin package, and run ./target/release/openethereum-evm stats --code 600160020160005260206000f3 You will see output 0x00000000000000000000000000000000000000000000000000000000000 00003 Stack Memory PUSH1 0x01 PUSH1 0x02 ADD PUSH1 0x00 MSTORE PUSH1 0x20 PUSH1 0x00 RETURN 0x00...20 0x00 0x00...00 ... 32 bytes ... 0x03 Return 0x00...03. End of execution. PC
Creation of a contract You can create a contract by a transaction. You provide the initialization OPCODE, which is usually provided by Solidity compiler. Example: Initialization OPCODE:
Creation of a contract The initialization OPCODE basically does one thing: store the highlighted OPCODE into the newly created contract.
Creation of a contract Now the contract is created: account-nonce: 0 balance: the value you payed (usually 0) code: account storage: empty address: hash of your information and code.
Calling/executing a contract Now any address can call this contract with the contract address. One can call this contract by providing: contract address call data gas fee (similar to transaction fee in Bitcoin) in a transaction.
Calling/executing a contract Example: contract address: the address just created call data: 0x448f30a3 gas fee: doesn t matter in private experiment Hash of this function.
call data: 0x448f30a3 OPCODE: State DB Stack Memory Storage empty empty ... ...
How does contract know which function in a contract? In the OPCODE, this sequence checks which function: CALLDATALOAD PUSH4 0x448f30a3 EQ Stack call data: 0x448f30a3 empty
How does contract know which function in a contract? In the OPCODE, this sequence checks which function: CALLDATALOAD PUSH4 0x448f30a3 EQ Stack call data: 0x448f30a3 0x00...448f30a3 Call data is loaded into stack. (And do padding.)
How does contract know which function in a contract? In the OPCODE, this sequence checks which function: CALLDATALOAD PUSH4 0x448f30a3 EQ Stack call data: 0x448f30a3 0x00...448f30a3 0x00...448f30a3 Push 0x448f30a3 into stack.
How does contract know which function in a contract? In the OPCODE, this sequence checks which function: CALLDATALOAD PUSH4 0x448f30a3 EQ Stack call data: 0x448f30a3 0x00...448f30a3 0x00...448f30a3 Check whether two items are equal (answer is yes). With yes , the contract can execute OPCODE that is for this function.
Features of OPCODE There are OPCODEs that call other contracts, create new contracts, thus enabling recursion. There are JUMP that controls pc, thus enabling if/else, for semantics in high-level languages.
Gas fee Starting point: prevent someone writes and runs an infinite loop. Gas cap: the maximum gas this transaction can use. Gas usage: the gas fee incurred by executing OPCODEs and other operations. Memory fee increases quadratically with usage. Storage fee is much heavier than memory fee. Base fee that every tx pays. If gas usage > gas cap, execution aborted. Gas price: decided by caller/sender. Actual fee = gas usage * gas price.
Gas fee However, gas fee rule is not a perfect measurement for the cost of running contracts and has changed many times. (E.g., some OPCODE may have too high/low gas fee.)
How about payment to users? Two types of account: User Contract account-nonce balance code: empty all the time account storage: empty all the time address: hash of your public key. account-nonce: 0 all the time balance: usually 0 all the time code: OPCODE account storage: read/write from code address: hash of creator s address and code. You holds a key pair. No key pair.
How about payment to users? Two types of transaction: Pay to User Call a Contract receiver: the user value gas capacity: set by sender gas price: set by sender call data: empty receiver: the contract value: usually 0 gas capacity: set by sender gas price: set by sender call data: the function and parameters, set by sender The gas fee is a small constant. The gas fee depends on the contract.
Also there is Create a Contract transaction, which is different from these two. How about payment to users? Two types of transaction: Pay to User Call a Contract receiver: the user value gas capacity: set by sender gas price: set by sender call data: empty receiver: the contract value: usually 0 gas capacity: set by sender gas price: set by sender call data: the function and parameters, set by sender The gas fee is a small constant. The gas fee depends on the contract.
How does this fit into a blockchain client? Virtual Machine Environment: Stack, memory, pc, etc.
References Ethereum Yellow Book Solidity website https://ethervm.io/decompile
