ethereum.constantinople.vm.gasethereum.istanbul.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)
27
GAS_SLOAD = Uint(800)

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)
42
GAS_BALANCE = Uint(700)

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)

GAS_CODE_HASH

64
GAS_CODE_HASH = Uint(400)
64
GAS_CODE_HASH = Uint(700)

GAS_FAST_STEP

65
GAS_FAST_STEP = Uint(5)

GAS_BLAKE2_PER_ROUND

66
GAS_BLAKE2_PER_ROUND = Uint(1)

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

69
@dataclass
class ExtendMemory:

cost

80
    cost: Uint

expand_by

81
    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

84
@dataclass
class MessageCallGas:

cost

97
    cost: Uint

stipend

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