ethereum.spurious_dragon.transactionsethereum.byzantium.transactions

Transactions are atomic units of work created externally to Ethereum and submitted to be executed. If Ethereum is viewed as a state machine, transactions are the events that move between states.

TX_BASE_COST

Base cost of a transaction in gas units. This is the minimum amount of gas required to execute a transaction.

23
TX_BASE_COST = Uint(21000)

TX_DATA_COST_PER_NON_ZERO

Gas cost per non-zero byte in the transaction data.

29
TX_DATA_COST_PER_NON_ZERO = Uint(68)

TX_DATA_COST_PER_ZERO

Gas cost per zero byte in the transaction data.

34
TX_DATA_COST_PER_ZERO = Uint(4)

TX_CREATE_COST

Additional gas cost for creating a new contract.

39
TX_CREATE_COST = Uint(32000)

Transaction

Atomic operation performed on the block chain.

45
@slotted_freezable
46
@dataclass
class Transaction:

nonce

A scalar value equal to the number of transactions sent by the sender.

52
    nonce: U256

gas_price

The price of gas for this transaction, in wei.

57
    gas_price: Uint

gas

The maximum amount of gas that can be used by this transaction.

62
    gas: Uint

to

The address of the recipient. If empty, the transaction is a contract creation.

67
    to: Bytes0 | Address

value

The amount of ether (in wei) to send with this transaction.

73
    value: U256

data

The data payload of the transaction, which can be used to call functions on contracts or to create new contracts.

78
    data: Bytes

v

The recovery id of the signature.

84
    v: U256

r

The first part of the signature.

89
    r: U256

s

The second part of the signature.

94
    s: U256

validate_transaction

Verifies a transaction.

The gas in a transaction gets used to pay for the intrinsic cost of operations, therefore if there is insufficient gas then it would not be possible to execute a transaction and it will be declared invalid.

Additionally, the nonce of a transaction must not equal or exceed the limit defined in EIP-2681. In practice, defining the limit as 2**64-1 has no impact because sending 2**64-1 transactions is improbable. It's not strictly impossible though, 2**64-1 transactions is the entire capacity of the Ethereum blockchain at 2022 gas limits for a little over 22 years.

This function takes a transaction as a parameter and returns the intrinsic gas cost of the transaction after validation. It throws an InsufficientTransactionGasError exception if the transaction does not provide enough gas to cover the intrinsic cost, and a NonceOverflowError exception if the nonce is greater than 2**64 - 2.

def validate_transaction(tx: Transaction) -> Uint:
101
    """
102
    Verifies a transaction.
103
104
    The gas in a transaction gets used to pay for the intrinsic cost of
105
    operations, therefore if there is insufficient gas then it would not
106
    be possible to execute a transaction and it will be declared invalid.
107
108
    Additionally, the nonce of a transaction must not equal or exceed the
109
    limit defined in [EIP-2681].
110
    In practice, defining the limit as ``2**64-1`` has no impact because
111
    sending ``2**64-1`` transactions is improbable. It's not strictly
112
    impossible though, ``2**64-1`` transactions is the entire capacity of the
113
    Ethereum blockchain at 2022 gas limits for a little over 22 years.
114
115
    This function takes a transaction as a parameter and returns the intrinsic
116
    gas cost of the transaction after validation. It throws an
117
    `InsufficientTransactionGasError` exception if the transaction does not
118
    provide enough gas to cover the intrinsic cost, and a `NonceOverflowError`
119
    exception if the nonce is greater than `2**64 - 2`.
120
121
    [EIP-2681]: https://eips.ethereum.org/EIPS/eip-2681
122
    """
123
    intrinsic_gas = calculate_intrinsic_cost(tx)
124
    if intrinsic_gas > tx.gas:
125
        raise InsufficientTransactionGasError("Insufficient gas")
126
    if U256(tx.nonce) >= U256(U64.MAX_VALUE):
127
        raise NonceOverflowError("Nonce too high")
128
    return intrinsic_gas

calculate_intrinsic_cost

Calculates the gas that is charged before execution is started.

The intrinsic cost of the transaction is charged before execution has begun. Functions/operations in the EVM cost money to execute so this intrinsic cost is for the operations that need to be paid for as part of the transaction. Data transfer, for example, is part of this intrinsic cost. It costs ether to send data over the wire and that ether is accounted for in the intrinsic cost calculated in this function. This intrinsic cost must be calculated and paid for before execution in order for all operations to be implemented.

The intrinsic cost includes:

  1. Base cost (TX_BASE_COST)

  2. Cost for data (zero and non-zero bytes)

  3. Cost for contract creation (if applicable)

This function takes a transaction as a parameter and returns the intrinsic gas cost of the transaction.

def calculate_intrinsic_cost(tx: Transaction) -> Uint:
132
    """
133
    Calculates the gas that is charged before execution is started.
134
135
    The intrinsic cost of the transaction is charged before execution has
136
    begun. Functions/operations in the EVM cost money to execute so this
137
    intrinsic cost is for the operations that need to be paid for as part of
138
    the transaction. Data transfer, for example, is part of this intrinsic
139
    cost. It costs ether to send data over the wire and that ether is
140
    accounted for in the intrinsic cost calculated in this function. This
141
    intrinsic cost must be calculated and paid for before execution in order
142
    for all operations to be implemented.
143
144
    The intrinsic cost includes:
145
    1. Base cost (`TX_BASE_COST`)
146
    2. Cost for data (zero and non-zero bytes)
147
    3. Cost for contract creation (if applicable)
148
149
    This function takes a transaction as a parameter and returns the intrinsic
150
    gas cost of the transaction.
151
    """
152
    data_cost = Uint(0)
153
154
    for byte in tx.data:
155
        if byte == 0:
156
            data_cost += TX_DATA_COST_PER_ZERO
157
        else:
158
            data_cost += TX_DATA_COST_PER_NON_ZERO
159
160
    if tx.to == Bytes0(b""):
161
        create_cost = TX_CREATE_COST
162
    else:
163
        create_cost = Uint(0)
164
165
    return TX_BASE_COST + data_cost + create_cost

recover_sender

Extracts the sender address from a transaction.

The v, r, and s values are the three parts that make up the signature of a transaction. In order to recover the sender of a transaction the two components needed are the signature (v, r, and s) and the signing hash of the transaction. The sender's public key can be obtained with these two values and therefore the sender address can be retrieved.

This function takes chain_id and a transaction as parameters and returns the address of the sender of the transaction. It raises an InvalidSignatureError if the signature values (r, s, v) are invalid.

def recover_sender(chain_id: U64, ​​tx: Transaction) -> Address:
169
    """
170
    Extracts the sender address from a transaction.
171
172
    The v, r, and s values are the three parts that make up the signature
173
    of a transaction. In order to recover the sender of a transaction the two
174
    components needed are the signature (``v``, ``r``, and ``s``) and the
175
    signing hash of the transaction. The sender's public key can be obtained
176
    with these two values and therefore the sender address can be retrieved.
177
178
    This function takes chain_id and a transaction as parameters and returns
179
    the address of the sender of the transaction. It raises an
180
    `InvalidSignatureError` if the signature values (r, s, v) are invalid.
181
    """
182
    v, r, s = tx.v, tx.r, tx.s
183
    if U256(0) >= r or r >= SECP256K1N:
184
        raise InvalidSignatureError("bad r")
185
    if U256(0) >= s or s > SECP256K1N // U256(2):
186
        raise InvalidSignatureError("bad s")
187
188
    if v == 27 or v == 28:
189
        public_key = secp256k1_recover(
190
            r, s, v - U256(27), signing_hash_pre155(tx)
191
        )
192
    else:
193
        chain_id_x2 = U256(chain_id) * U256(2)
194
        if v != U256(35) + chain_id_x2 and v != U256(36) + chain_id_x2:
195
            raise InvalidSignatureError("bad v")
196
        public_key = secp256k1_recover(
197
            r, s, v - U256(35) - chain_id_x2, signing_hash_155(tx, chain_id)
198
        )
199
200
    return Address(keccak256(public_key)[12:32])

signing_hash_pre155

Compute the hash of a transaction used in a legacy (pre EIP-155) signature.

This function takes a transaction as a parameter and returns the signing hash of the transaction.

def signing_hash_pre155(tx: Transaction) -> Hash32:
204
    """
205
    Compute the hash of a transaction used in a legacy (pre [EIP-155])
206
    signature.
207
208
    This function takes a transaction as a parameter and returns the
209
    signing hash of the transaction.
210
211
    [EIP-155]: https://eips.ethereum.org/EIPS/eip-155
212
    """
213
    return keccak256(
214
        rlp.encode(
215
            (
216
                tx.nonce,
217
                tx.gas_price,
218
                tx.gas,
219
                tx.to,
220
                tx.value,
221
                tx.data,
222
            )
223
        )
224
    )

signing_hash_155

Compute the hash of a transaction used in a EIP-155 signature.

This function takes a transaction and chain ID as parameters and returns the hash of the transaction used in a EIP-155 signature.

def signing_hash_155(tx: Transaction, ​​chain_id: U64) -> Hash32:
228
    """
229
    Compute the hash of a transaction used in a [EIP-155] signature.
230
231
    This function takes a transaction and chain ID as parameters and returns
232
    the hash of the transaction used in a [EIP-155] signature.
233
234
    [EIP-155]: https://eips.ethereum.org/EIPS/eip-155
235
    """
236
    return keccak256(
237
        rlp.encode(
238
            (
239
                tx.nonce,
240
                tx.gas_price,
241
                tx.gas,
242
                tx.to,
243
                tx.value,
244
                tx.data,
245
                chain_id,
246
                Uint(0),
247
                Uint(0),
248
            )
249
        )
250
    )

get_transaction_hash

Compute the hash of a transaction.

This function takes a transaction as a parameter and returns the hash of the transaction.

def get_transaction_hash(tx: Transaction) -> Hash32:
254
    """
255
    Compute the hash of a transaction.
256
257
    This function takes a transaction as a parameter and returns the
258
    hash of the transaction.
259
    """
260
    return keccak256(rlp.encode(tx))