ethereum.forks.tangerine_whistle.transactionsethereum.forks.spurious_dragon.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.

Transaction

Atomic operation performed on the block chain.

25
@final
26
@slotted_freezable
27
@dataclass
class Transaction:

nonce

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

33
    nonce: U256

gas_price

The price of gas for this transaction, in wei.

38
    gas_price: Uint

gas

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

43
    gas: Uint

to

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

48
    to: Bytes0 | Address

value

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

54
    value: U256

data

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

59
    data: Bytes

v

The recovery id of the signature.

65
    v: U256

r

The first part of the signature.

70
    r: U256

s

The second part of the signature.

75
    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:
82
    <snip>
104
    intrinsic_gas = calculate_intrinsic_cost(tx)
105
    if intrinsic_gas > tx.gas:
106
        raise InsufficientTransactionGasError("Insufficient gas")
107
    if U256(tx.nonce) >= U256(U64.MAX_VALUE):
108
        raise NonceOverflowError("Nonce too high")
109
    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)

  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:
113
    <snip>
133
    from .vm.gas import GasCosts
134
135
    num_zeros = Uint(tx.data.count(0))
136
    num_non_zeros = ulen(tx.data) - num_zeros
137
    data_cost = (
138
        num_zeros * GasCosts.TX_DATA_PER_ZERO
139
        + num_non_zeros * GasCosts.TX_DATA_PER_NON_ZERO
140
    )
141
142
    if tx.to == Bytes0(b""):
143
        create_cost = GasCosts.TX_CREATE
144
    else:
145
        create_cost = Uint(0)
146
147
    return GasCosts.TX_BASE + data_cost + create_cost

chain_id

Extract the chain identifier from a transaction. See EIP-155.

def chain_id(​tx: Transaction​) -> None | U64:
151
    <snip>
156
    if tx.v == 27 or tx.v == 28:
157
        return None
158
    if tx.v < U256(35):
159
        raise InvalidSignatureError("bad v")
160
    return U64((tx.v - U256(35)) >> U256(1))

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 a transaction as a parameter and returnsThis 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(​tx: Transaction​) -> Address:
164
    <snip>
177
    v, r, s = tx.v, tx.r, tx.s
165
    if v != 27 and v != 28:
166
        raise InvalidSignatureError("bad v")
178
    if U256(0) >= r or r >= SECP256K1N:
179
        raise InvalidSignatureError("bad r")
180
    if U256(0) >= s or s > SECP256K1N // U256(2):
181
        raise InvalidSignatureError("bad s")
182
172
    public_key = secp256k1_recover(r, s, v - U256(27), signing_hash(tx))
183
    if v == 27 or v == 28:
184
        public_key = secp256k1_recover(
185
            r, s, v - U256(27), signing_hash_pre155(tx)
186
        )
187
    else:
188
        assert v >= U256(35), "call chain_id before recover_sender"
189
        tx_chain_id = U64((v - U256(35)) >> U256(1))
190
        v = (v - U256(35)) & U256(1)
191
        public_key = secp256k1_recover(
192
            r, s, v, signing_hash_155(tx, tx_chain_id)
193
        )
194
195
    return Address(keccak256(public_key)[12:32])

signing_hash

Compute the hash of a transaction used in the signature.

The values that are used to compute the signing hash set the rules for a transaction. For example, signing over the gas sets a limit for the amount of money that is allowed to be pulled out of the sender's account.

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

def signing_hash(​tx: Transaction​) -> Hash32:
177
    <snip>
187
    return keccak256(
188
        rlp.encode(
189
            (
190
                tx.nonce,
191
                tx.gas_price,
192
                tx.gas,
193
                tx.to,
194
                tx.value,
195
                tx.data,
196
            )
197
        )
198
    )

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:
199
    <snip>
208
    return keccak256(
209
        rlp.encode(
210
            (
211
                tx.nonce,
212
                tx.gas_price,
213
                tx.gas,
214
                tx.to,
215
                tx.value,
216
                tx.data,
217
            )
218
        )
219
    )

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:
223
    <snip>
231
    return keccak256(
232
        rlp.encode(
233
            (
234
                tx.nonce,
235
                tx.gas_price,
236
                tx.gas,
237
                tx.to,
238
                tx.value,
239
                tx.data,
240
                chain_id,
241
                Uint(0),
242
                Uint(0),
243
            )
244
        )
245
    )

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:
249
    <snip>
255
    return keccak256(rlp.encode(tx))