ethereum.dao_fork.vm.gas

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

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

Introduction

EVM gas constants and calculators.

GAS_JUMPDEST

27
GAS_JUMPDEST = Uint(1)

GAS_BASE

28
GAS_BASE = Uint(2)

GAS_VERY_LOW

29
GAS_VERY_LOW = Uint(3)

GAS_SLOAD

30
GAS_SLOAD = Uint(50)

GAS_STORAGE_SET

31
GAS_STORAGE_SET = Uint(20000)

GAS_STORAGE_UPDATE

32
GAS_STORAGE_UPDATE = Uint(5000)

GAS_STORAGE_CLEAR_REFUND

33
GAS_STORAGE_CLEAR_REFUND = Uint(15000)

GAS_LOW

34
GAS_LOW = Uint(5)

GAS_MID

35
GAS_MID = Uint(8)

GAS_HIGH

36
GAS_HIGH = Uint(10)

GAS_EXPONENTIATION

37
GAS_EXPONENTIATION = Uint(10)

GAS_EXPONENTIATION_PER_BYTE

38
GAS_EXPONENTIATION_PER_BYTE = Uint(10)

GAS_MEMORY

39
GAS_MEMORY = Uint(3)

GAS_KECCAK256

40
GAS_KECCAK256 = Uint(30)

GAS_KECCAK256_WORD

41
GAS_KECCAK256_WORD = Uint(6)

GAS_COPY

42
GAS_COPY = Uint(3)

GAS_BLOCK_HASH

43
GAS_BLOCK_HASH = Uint(20)

GAS_EXTERNAL

44
GAS_EXTERNAL = Uint(20)

GAS_BALANCE

45
GAS_BALANCE = Uint(20)

GAS_LOG

46
GAS_LOG = Uint(375)

GAS_LOG_DATA

47
GAS_LOG_DATA = Uint(8)

GAS_LOG_TOPIC

48
GAS_LOG_TOPIC = Uint(375)

GAS_CREATE

49
GAS_CREATE = Uint(32000)

GAS_CODE_DEPOSIT

50
GAS_CODE_DEPOSIT = Uint(200)

GAS_ZERO

51
GAS_ZERO = Uint(0)

GAS_CALL

52
GAS_CALL = Uint(40)

GAS_NEW_ACCOUNT

53
GAS_NEW_ACCOUNT = Uint(25000)

GAS_CALL_VALUE

54
GAS_CALL_VALUE = Uint(9000)

GAS_CALL_STIPEND

55
GAS_CALL_STIPEND = Uint(2300)

REFUND_SELF_DESTRUCT

56
REFUND_SELF_DESTRUCT = Uint(24000)

GAS_ECRECOVER

57
GAS_ECRECOVER = Uint(3000)

GAS_SHA256

58
GAS_SHA256 = Uint(60)

GAS_SHA256_WORD

59
GAS_SHA256_WORD = Uint(12)

GAS_RIPEMD160

60
GAS_RIPEMD160 = Uint(600)

GAS_RIPEMD160_WORD

61
GAS_RIPEMD160_WORD = Uint(120)

GAS_IDENTITY

62
GAS_IDENTITY = Uint(15)

GAS_IDENTITY_WORD

63
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

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(int(amount)))
111
112
    if evm.gas_left < amount:
113
        raise OutOfGasError
114
    else:
115
        evm.gas_left -= 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) // Uint(32)
135
    linear_cost = size_in_words * GAS_MEMORY
136
    quadratic_cost = size_in_words ** Uint(2) // Uint(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 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:
186
    """
187
    Calculates the gas amount for executing Opcodes `CALL` and `CALLCODE`.
188
189
    Parameters
190
    ----------
191
    state :
192
        The current state.
193
    gas :
194
        The amount of gas provided to the message-call.
195
    to:
196
        The address of the recipient account.
197
    value:
198
        The amount of `ETH` that needs to be transferred.
199
200
    Returns
201
    -------
202
    message_call_gas: `MessageCallGas`
203
    """
204
    create_gas_cost = Uint(0) if account_exists(state, to) else GAS_NEW_ACCOUNT
205
    transfer_gas_cost = Uint(0) if value == 0 else GAS_CALL_VALUE
206
    cost = GAS_CALL + gas + create_gas_cost + transfer_gas_cost
207
    stipend = gas if value == 0 else GAS_CALL_STIPEND + gas
208
    return MessageCallGas(cost, stipend)