ethereum.berlin.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_STORAGE_SET

27
GAS_STORAGE_SET = Uint(20000)

GAS_STORAGE_UPDATE

28
GAS_STORAGE_UPDATE = Uint(5000)

GAS_STORAGE_CLEAR_REFUND

29
GAS_STORAGE_CLEAR_REFUND = Uint(15000)

GAS_LOW

30
GAS_LOW = Uint(5)

GAS_MID

31
GAS_MID = Uint(8)

GAS_HIGH

32
GAS_HIGH = Uint(10)

GAS_EXPONENTIATION

33
GAS_EXPONENTIATION = Uint(10)

GAS_EXPONENTIATION_PER_BYTE

34
GAS_EXPONENTIATION_PER_BYTE = Uint(50)

GAS_MEMORY

35
GAS_MEMORY = Uint(3)

GAS_KECCAK256

36
GAS_KECCAK256 = Uint(30)

GAS_KECCAK256_WORD

37
GAS_KECCAK256_WORD = Uint(6)

GAS_COPY

38
GAS_COPY = Uint(3)

GAS_BLOCK_HASH

39
GAS_BLOCK_HASH = Uint(20)

GAS_LOG

40
GAS_LOG = Uint(375)

GAS_LOG_DATA

41
GAS_LOG_DATA = Uint(8)

GAS_LOG_TOPIC

42
GAS_LOG_TOPIC = Uint(375)

GAS_CREATE

43
GAS_CREATE = Uint(32000)

GAS_CODE_DEPOSIT

44
GAS_CODE_DEPOSIT = Uint(200)

GAS_ZERO

45
GAS_ZERO = Uint(0)

GAS_NEW_ACCOUNT

46
GAS_NEW_ACCOUNT = Uint(25000)

GAS_CALL_VALUE

47
GAS_CALL_VALUE = Uint(9000)

GAS_CALL_STIPEND

48
GAS_CALL_STIPEND = Uint(2300)

GAS_SELF_DESTRUCT

49
GAS_SELF_DESTRUCT = Uint(5000)

GAS_SELF_DESTRUCT_NEW_ACCOUNT

50
GAS_SELF_DESTRUCT_NEW_ACCOUNT = Uint(25000)

REFUND_SELF_DESTRUCT

51
REFUND_SELF_DESTRUCT = Uint(24000)

GAS_ECRECOVER

52
GAS_ECRECOVER = Uint(3000)

GAS_SHA256

53
GAS_SHA256 = Uint(60)

GAS_SHA256_WORD

54
GAS_SHA256_WORD = Uint(12)

GAS_RIPEMD160

55
GAS_RIPEMD160 = Uint(600)

GAS_RIPEMD160_WORD

56
GAS_RIPEMD160_WORD = Uint(120)

GAS_IDENTITY

57
GAS_IDENTITY = Uint(15)

GAS_IDENTITY_WORD

58
GAS_IDENTITY_WORD = Uint(3)

GAS_RETURN_DATA_COPY

59
GAS_RETURN_DATA_COPY = Uint(3)

GAS_FAST_STEP

60
GAS_FAST_STEP = Uint(5)

GAS_BLAKE2_PER_ROUND

61
GAS_BLAKE2_PER_ROUND = Uint(1)

GAS_COLD_SLOAD

62
GAS_COLD_SLOAD = Uint(2100)

GAS_COLD_ACCOUNT_ACCESS

63
GAS_COLD_ACCOUNT_ACCESS = Uint(2600)

GAS_WARM_ACCESS

64
GAS_WARM_ACCESS = Uint(100)

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

67
@dataclass
class ExtendMemory:

cost

78
    cost: Uint

expand_by

79
    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

82
@dataclass
class MessageCallGas:

cost

95
    cost: Uint

stipend

96
    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:
100
    """
101
    Subtracts `amount` from `evm.gas_left`.
102
103
    Parameters
104
    ----------
105
    evm :
106
        The current EVM.
107
    amount :
108
        The amount of gas the current operation requires.
109
110
    """
111
    evm_trace(evm, GasAndRefund(amount))
112
113
    if evm.gas_left < amount:
114
        raise OutOfGasError
115
    else:
116
        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:
120
    """
121
    Calculates the gas cost for allocating memory
122
    to the smallest multiple of 32 bytes,
123
    such that the allocated size is at least as big as the given size.
124
125
    Parameters
126
    ----------
127
    size_in_bytes :
128
        The size of the data in bytes.
129
130
    Returns
131
    -------
132
    total_gas_cost : `ethereum.base_types.Uint`
133
        The gas cost for storing data in memory.
134
    """
135
    size_in_words = ceil32(size_in_bytes) // 32
136
    linear_cost = size_in_words * GAS_MEMORY
137
    quadratic_cost = size_in_words**2 // 512
138
    total_gas_cost = linear_cost + quadratic_cost
139
    try:
140
        return total_gas_cost
141
    except ValueError:
142
        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:
148
    """
149
    Calculates the gas amount to extend memory
150
151
    Parameters
152
    ----------
153
    memory :
154
        Memory contents of the EVM.
155
    extensions:
156
        List of extensions to be made to the memory.
157
        Consists of a tuple of start position and size.
158
159
    Returns
160
    -------
161
    extend_memory: `ExtendMemory`
162
    """
163
    size_to_extend = Uint(0)
164
    to_be_paid = Uint(0)
165
    current_size = Uint(len(memory))
166
    for start_position, size in extensions:
167
        if size == 0:
168
            continue
169
        before_size = ceil32(current_size)
170
        after_size = ceil32(Uint(start_position) + Uint(size))
171
        if after_size <= before_size:
172
            continue
173
174
        size_to_extend += after_size - before_size
175
        already_paid = calculate_memory_gas_cost(before_size)
176
        total_cost = calculate_memory_gas_cost(after_size)
177
        to_be_paid += total_cost - already_paid
178
179
        current_size = after_size
180
181
    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:
192
    """
193
    Calculates the MessageCallGas (cost and stipend) for
194
    executing call Opcodes.
195
196
    Parameters
197
    ----------
198
    value:
199
        The amount of `ETH` that needs to be transferred.
200
    gas :
201
        The amount of gas provided to the message-call.
202
    gas_left :
203
        The amount of gas left in the current frame.
204
    memory_cost :
205
        The amount needed to extend the memory in the current frame.
206
    extra_gas :
207
        The amount of gas needed for transferring value + creating a new
208
        account inside a message call.
209
    call_stipend :
210
        The amount of stipend provided to a message call to execute code while
211
        transferring value(ETH).
212
213
    Returns
214
    -------
215
    message_call_gas: `MessageCallGas`
216
    """
217
    call_stipend = Uint(0) if value == 0 else call_stipend
218
    if gas_left < extra_gas + memory_cost:
219
        return MessageCallGas(gas + extra_gas, gas + call_stipend)
220
221
    gas = min(gas, max_message_call_gas(gas_left - memory_cost - extra_gas))
222
223
    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:
227
    """
228
    Calculates the maximum gas that is allowed for making a message call
229
230
    Parameters
231
    ----------
232
    gas :
233
        The amount of gas provided to the message-call.
234
235
    Returns
236
    -------
237
    max_allowed_message_call_gas: `ethereum.base_types.Uint`
238
        The maximum gas allowed for making the message-call.
239
    """
240
    return gas - (gas // 64)