ethereum.homestead.vm.gas

Ethereum Virtual Machine (EVM) Gas ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

.. contents:: Table of Contents :backlinks: none :local:

Introduction

EVM gas constants and calculators.

GAS_JUMPDEST

26
GAS_JUMPDEST = Uint(1)

GAS_BASE

27
GAS_BASE = Uint(2)

GAS_VERY_LOW

28
GAS_VERY_LOW = Uint(3)

GAS_SLOAD

29
GAS_SLOAD = Uint(50)

GAS_STORAGE_SET

30
GAS_STORAGE_SET = Uint(20000)

GAS_STORAGE_UPDATE

31
GAS_STORAGE_UPDATE = Uint(5000)

GAS_STORAGE_CLEAR_REFUND

32
GAS_STORAGE_CLEAR_REFUND = Uint(15000)

GAS_LOW

33
GAS_LOW = Uint(5)

GAS_MID

34
GAS_MID = Uint(8)

GAS_HIGH

35
GAS_HIGH = Uint(10)

GAS_EXPONENTIATION

36
GAS_EXPONENTIATION = Uint(10)

GAS_EXPONENTIATION_PER_BYTE

37
GAS_EXPONENTIATION_PER_BYTE = Uint(10)

GAS_MEMORY

38
GAS_MEMORY = Uint(3)

GAS_KECCAK256

39
GAS_KECCAK256 = Uint(30)

GAS_KECCAK256_WORD

40
GAS_KECCAK256_WORD = Uint(6)

GAS_COPY

41
GAS_COPY = Uint(3)

GAS_BLOCK_HASH

42
GAS_BLOCK_HASH = Uint(20)

GAS_EXTERNAL

43
GAS_EXTERNAL = Uint(20)

GAS_BALANCE

44
GAS_BALANCE = Uint(20)

GAS_LOG

45
GAS_LOG = Uint(375)

GAS_LOG_DATA

46
GAS_LOG_DATA = Uint(8)

GAS_LOG_TOPIC

47
GAS_LOG_TOPIC = Uint(375)

GAS_CREATE

48
GAS_CREATE = Uint(32000)

GAS_CODE_DEPOSIT

49
GAS_CODE_DEPOSIT = Uint(200)

GAS_ZERO

50
GAS_ZERO = Uint(0)

GAS_CALL

51
GAS_CALL = Uint(40)

GAS_NEW_ACCOUNT

52
GAS_NEW_ACCOUNT = Uint(25000)

GAS_CALL_VALUE

53
GAS_CALL_VALUE = Uint(9000)

GAS_CALL_STIPEND

54
GAS_CALL_STIPEND = Uint(2300)

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)

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

65
@dataclass
class ExtendMemory:

cost

76
    cost: Uint

expand_by

77
    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

80
@dataclass
class MessageCallGas:

cost

93
    cost: Uint

stipend

94
    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:
98
    """
99
    Subtracts `amount` from `evm.gas_left`.
100
101
    Parameters
102
    ----------
103
    evm :
104
        The current EVM.
105
    amount :
106
        The amount of gas the current operation requires.
107
108
    """
109
    evm_trace(evm, GasAndRefund(amount))
110
111
    if evm.gas_left < amount:
112
        raise OutOfGasError
113
    else:
114
        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:
118
    """
119
    Calculates the gas cost for allocating memory
120
    to the smallest multiple of 32 bytes,
121
    such that the allocated size is at least as big as the given size.
122
123
    Parameters
124
    ----------
125
    size_in_bytes :
126
        The size of the data in bytes.
127
128
    Returns
129
    -------
130
    total_gas_cost : `ethereum.base_types.Uint`
131
        The gas cost for storing data in memory.
132
    """
133
    size_in_words = ceil32(size_in_bytes) // 32
134
    linear_cost = size_in_words * GAS_MEMORY
135
    quadratic_cost = size_in_words**2 // 512
136
    total_gas_cost = linear_cost + quadratic_cost
137
    try:
138
        return total_gas_cost
139
    except ValueError:
140
        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:
146
    """
147
    Calculates the gas amount to extend memory
148
149
    Parameters
150
    ----------
151
    memory :
152
        Memory contents of the EVM.
153
    extensions:
154
        List of extensions to be made to the memory.
155
        Consists of a tuple of start position and size.
156
157
    Returns
158
    -------
159
    extend_memory: `ExtendMemory`
160
    """
161
    size_to_extend = Uint(0)
162
    to_be_paid = Uint(0)
163
    current_size = Uint(len(memory))
164
    for start_position, size in extensions:
165
        if size == 0:
166
            continue
167
        before_size = ceil32(current_size)
168
        after_size = ceil32(Uint(start_position) + Uint(size))
169
        if after_size <= before_size:
170
            continue
171
172
        size_to_extend += after_size - before_size
173
        already_paid = calculate_memory_gas_cost(before_size)
174
        total_cost = calculate_memory_gas_cost(after_size)
175
        to_be_paid += total_cost - already_paid
176
177
        current_size = after_size
178
179
    return ExtendMemory(to_be_paid, size_to_extend)

calculate_message_call_gas

Calculates the gas amount for executing Opcodes CALL and CALLCODE.

Parameters

state : The current state. gas : The amount of gas provided to the message-call. to: The address of the recipient account. value: The amount of ETH that needs to be transferred.

Returns

message_call_gas: MessageCallGas

def calculate_message_call_gas(​state: State, ​​gas: Uint, ​​to: Address, ​​value: U256​) -> MessageCallGas:
185
    """
186
    Calculates the gas amount for executing Opcodes `CALL` and `CALLCODE`.
187
188
    Parameters
189
    ----------
190
    state :
191
        The current state.
192
    gas :
193
        The amount of gas provided to the message-call.
194
    to:
195
        The address of the recipient account.
196
    value:
197
        The amount of `ETH` that needs to be transferred.
198
199
    Returns
200
    -------
201
    message_call_gas: `MessageCallGas`
202
    """
203
    create_gas_cost = Uint(0) if account_exists(state, to) else GAS_NEW_ACCOUNT
204
    transfer_gas_cost = Uint(0) if value == 0 else GAS_CALL_VALUE
205
    cost = GAS_CALL + gas + create_gas_cost + transfer_gas_cost
206
    stipend = gas if value == 0 else GAS_CALL_STIPEND + gas
207
    return MessageCallGas(cost, stipend)