ethereum.byzantium.vm.gas
Ethereum Virtual Machine (EVM) Gas ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
.. contents:: Table of Contents :backlinks: none :local:
Introduction
EVM gas constants and calculators.
GAS_JUMPDEST
24 | GAS_JUMPDEST = Uint(1) |
---|
GAS_BASE
25 | GAS_BASE = Uint(2) |
---|
GAS_VERY_LOW
26 | GAS_VERY_LOW = Uint(3) |
---|
GAS_SLOAD
27 | GAS_SLOAD = Uint(200) |
---|
GAS_STORAGE_SET
28 | GAS_STORAGE_SET = Uint(20000) |
---|
GAS_STORAGE_UPDATE
29 | GAS_STORAGE_UPDATE = Uint(5000) |
---|
GAS_STORAGE_CLEAR_REFUND
30 | GAS_STORAGE_CLEAR_REFUND = Uint(15000) |
---|
GAS_LOW
31 | GAS_LOW = Uint(5) |
---|
GAS_MID
32 | GAS_MID = Uint(8) |
---|
GAS_HIGH
33 | GAS_HIGH = Uint(10) |
---|
GAS_EXPONENTIATION
34 | GAS_EXPONENTIATION = Uint(10) |
---|
GAS_EXPONENTIATION_PER_BYTE
35 | GAS_EXPONENTIATION_PER_BYTE = Uint(50) |
---|
GAS_MEMORY
36 | GAS_MEMORY = Uint(3) |
---|
GAS_KECCAK256
37 | GAS_KECCAK256 = Uint(30) |
---|
GAS_KECCAK256_WORD
38 | GAS_KECCAK256_WORD = Uint(6) |
---|
GAS_COPY
39 | GAS_COPY = Uint(3) |
---|
GAS_BLOCK_HASH
40 | GAS_BLOCK_HASH = Uint(20) |
---|
GAS_EXTERNAL
41 | GAS_EXTERNAL = Uint(700) |
---|
GAS_BALANCE
42 | GAS_BALANCE = Uint(400) |
---|
GAS_LOG
43 | GAS_LOG = Uint(375) |
---|
GAS_LOG_DATA
44 | GAS_LOG_DATA = Uint(8) |
---|
GAS_LOG_TOPIC
45 | GAS_LOG_TOPIC = Uint(375) |
---|
GAS_CREATE
46 | GAS_CREATE = Uint(32000) |
---|
GAS_CODE_DEPOSIT
47 | GAS_CODE_DEPOSIT = Uint(200) |
---|
GAS_ZERO
48 | GAS_ZERO = Uint(0) |
---|
GAS_CALL
49 | GAS_CALL = Uint(700) |
---|
GAS_NEW_ACCOUNT
50 | GAS_NEW_ACCOUNT = Uint(25000) |
---|
GAS_CALL_VALUE
51 | GAS_CALL_VALUE = Uint(9000) |
---|
GAS_CALL_STIPEND
52 | GAS_CALL_STIPEND = Uint(2300) |
---|
GAS_SELF_DESTRUCT
53 | GAS_SELF_DESTRUCT = Uint(5000) |
---|
GAS_SELF_DESTRUCT_NEW_ACCOUNT
54 | GAS_SELF_DESTRUCT_NEW_ACCOUNT = Uint(25000) |
---|
REFUND_SELF_DESTRUCT
55 | REFUND_SELF_DESTRUCT = Uint(24000) |
---|
GAS_ECRECOVER
56 | GAS_ECRECOVER = Uint(3000) |
---|
GAS_SHA256
57 | GAS_SHA256 = Uint(60) |
---|
GAS_SHA256_WORD
58 | GAS_SHA256_WORD = Uint(12) |
---|
GAS_RIPEMD160
59 | GAS_RIPEMD160 = Uint(600) |
---|
GAS_RIPEMD160_WORD
60 | GAS_RIPEMD160_WORD = Uint(120) |
---|
GAS_IDENTITY
61 | GAS_IDENTITY = Uint(15) |
---|
GAS_IDENTITY_WORD
62 | GAS_IDENTITY_WORD = Uint(3) |
---|
GAS_RETURN_DATA_COPY
63 | GAS_RETURN_DATA_COPY = Uint(3) |
---|
ExtendMemory
Define the parameters for memory extension in opcodes
cost
: ethereum.base_types.Uint
The gas required to perform the extension
expand_by
: ethereum.base_types.Uint
The size by which the memory will be extended
66 | @dataclass |
---|
class ExtendMemory:
cost
77 | cost: Uint |
---|
expand_by
78 | expand_by: Uint |
---|
MessageCallGas
Define the gas cost and stipend for executing the call opcodes.
cost
: ethereum.base_types.Uint
The non-refundable portion of gas reserved for executing the
call opcode.
stipend
: ethereum.base_types.Uint
The portion of gas available to sub-calls that is refundable
if not consumed
81 | @dataclass |
---|
class MessageCallGas:
cost
94 | cost: Uint |
---|
stipend
95 | stipend: Uint |
---|
charge_gas
Subtracts amount
from evm.gas_left
.
Parameters
evm : The current EVM. amount : The amount of gas the current operation requires.
def charge_gas(evm: Evm, amount: Uint) -> None:
99 | """ |
---|---|
100 | Subtracts `amount` from `evm.gas_left`. |
101 |
|
102 | Parameters |
103 | ---------- |
104 | evm : |
105 | The current EVM. |
106 | amount : |
107 | The amount of gas the current operation requires. |
108 |
|
109 | """ |
110 | evm_trace(evm, GasAndRefund(amount)) |
111 | |
112 | if evm.gas_left < amount: |
113 | raise OutOfGasError |
114 | else: |
115 | evm.gas_left -= U256(amount) |
calculate_memory_gas_cost
Calculates the gas cost for allocating memory to the smallest multiple of 32 bytes, such that the allocated size is at least as big as the given size.
Parameters
size_in_bytes : The size of the data in bytes.
Returns
total_gas_cost : ethereum.base_types.Uint
The gas cost for storing data in memory.
def calculate_memory_gas_cost(size_in_bytes: Uint) -> Uint:
119 | """ |
---|---|
120 | Calculates the gas cost for allocating memory |
121 | to the smallest multiple of 32 bytes, |
122 | such that the allocated size is at least as big as the given size. |
123 |
|
124 | Parameters |
125 | ---------- |
126 | size_in_bytes : |
127 | The size of the data in bytes. |
128 |
|
129 | Returns |
130 | ------- |
131 | total_gas_cost : `ethereum.base_types.Uint` |
132 | The gas cost for storing data in memory. |
133 | """ |
134 | size_in_words = ceil32(size_in_bytes) // 32 |
135 | linear_cost = size_in_words * GAS_MEMORY |
136 | quadratic_cost = size_in_words**2 // 512 |
137 | total_gas_cost = linear_cost + quadratic_cost |
138 | try: |
139 | return total_gas_cost |
140 | except ValueError: |
141 | raise OutOfGasError |
calculate_gas_extend_memory
Calculates the gas amount to extend memory
Parameters
memory : Memory contents of the EVM. extensions: List of extensions to be made to the memory. Consists of a tuple of start position and size.
Returns
extend_memory: ExtendMemory
def calculate_gas_extend_memory(memory: bytearray, extensions: List[Tuple[U256, U256]]) -> ExtendMemory:
147 | """ |
---|---|
148 | Calculates the gas amount to extend memory |
149 |
|
150 | Parameters |
151 | ---------- |
152 | memory : |
153 | Memory contents of the EVM. |
154 | extensions: |
155 | List of extensions to be made to the memory. |
156 | Consists of a tuple of start position and size. |
157 |
|
158 | Returns |
159 | ------- |
160 | extend_memory: `ExtendMemory` |
161 | """ |
162 | size_to_extend = Uint(0) |
163 | to_be_paid = Uint(0) |
164 | current_size = Uint(len(memory)) |
165 | for start_position, size in extensions: |
166 | if size == 0: |
167 | continue |
168 | before_size = ceil32(current_size) |
169 | after_size = ceil32(Uint(start_position) + Uint(size)) |
170 | if after_size <= before_size: |
171 | continue |
172 |
|
173 | size_to_extend += after_size - before_size |
174 | already_paid = calculate_memory_gas_cost(before_size) |
175 | total_cost = calculate_memory_gas_cost(after_size) |
176 | to_be_paid += total_cost - already_paid |
177 |
|
178 | current_size = after_size |
179 | |
180 | return ExtendMemory(to_be_paid, size_to_extend) |
calculate_message_call_gas
Calculates the MessageCallGas (cost and stipend) for executing call Opcodes.
Parameters
value:
The amount of ETH
that needs to be transferred.
gas :
The amount of gas provided to the message-call.
gas_left :
The amount of gas left in the current frame.
memory_cost :
The amount needed to extend the memory in the current frame.
extra_gas :
The amount of gas needed for transferring value + creating a new
account inside a message call.
call_stipend :
The amount of stipend provided to a message call to execute code while
transferring value(ETH).
Returns
message_call_gas: MessageCallGas
def calculate_message_call_gas(value: U256, gas: Uint, gas_left: Uint, memory_cost: Uint, extra_gas: Uint, call_stipend: Uint) -> MessageCallGas:
191 | """ |
---|---|
192 | Calculates the MessageCallGas (cost and stipend) for |
193 | executing call Opcodes. |
194 |
|
195 | Parameters |
196 | ---------- |
197 | value: |
198 | The amount of `ETH` that needs to be transferred. |
199 | gas : |
200 | The amount of gas provided to the message-call. |
201 | gas_left : |
202 | The amount of gas left in the current frame. |
203 | memory_cost : |
204 | The amount needed to extend the memory in the current frame. |
205 | extra_gas : |
206 | The amount of gas needed for transferring value + creating a new |
207 | account inside a message call. |
208 | call_stipend : |
209 | The amount of stipend provided to a message call to execute code while |
210 | transferring value(ETH). |
211 |
|
212 | Returns |
213 | ------- |
214 | message_call_gas: `MessageCallGas` |
215 | """ |
216 | call_stipend = Uint(0) if value == 0 else call_stipend |
217 | if gas_left < extra_gas + memory_cost: |
218 | return MessageCallGas(gas + extra_gas, gas + call_stipend) |
219 | |
220 | gas = min(gas, max_message_call_gas(gas_left - memory_cost - extra_gas)) |
221 | |
222 | return MessageCallGas(gas + extra_gas, gas + call_stipend) |
max_message_call_gas
Calculates the maximum gas that is allowed for making a message call
Parameters
gas : The amount of gas provided to the message-call.
Returns
max_allowed_message_call_gas: ethereum.base_types.Uint
The maximum gas allowed for making the message-call.
def max_message_call_gas(gas: Uint) -> Uint:
226 | """ |
---|---|
227 | Calculates the maximum gas that is allowed for making a message call |
228 |
|
229 | Parameters |
230 | ---------- |
231 | gas : |
232 | The amount of gas provided to the message-call. |
233 |
|
234 | Returns |
235 | ------- |
236 | max_allowed_message_call_gas: `ethereum.base_types.Uint` |
237 | The maximum gas allowed for making the message-call. |
238 | """ |
239 | return gas - (gas // 64) |