ethereum.homestead.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.

19
TX_BASE_COST = Uint(21000)

TX_DATA_COST_PER_NON_ZERO

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

25
TX_DATA_COST_PER_NON_ZERO = Uint(68)

TX_DATA_COST_PER_ZERO

Gas cost per zero byte in the transaction data.

30
TX_DATA_COST_PER_ZERO = Uint(4)

TX_CREATE_COST

Additional gas cost for creating a new contract.

35
TX_CREATE_COST = Uint(32000)

Transaction

Atomic operation performed on the block chain.

41
@slotted_freezable
42
@dataclass
class Transaction:

nonce

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

48
    nonce: U256

gas_price

The price of gas for this transaction, in wei.

53
    gas_price: Uint

gas

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

58
    gas: Uint

to

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

63
    to: Bytes0 | Address

value

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

69
    value: U256

data

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

74
    data: Bytes

v

The recovery id of the signature.

80
    v: U256

r

The first part of the signature.

85
    r: U256

s

The second part of the signature.

90
    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 InvalidTransaction exception if the transaction is invalid.

def validate_transaction(tx: Transaction) -> Uint:
97
    """
98
    Verifies a transaction.
99
100
    The gas in a transaction gets used to pay for the intrinsic cost of
101
    operations, therefore if there is insufficient gas then it would not
102
    be possible to execute a transaction and it will be declared invalid.
103
104
    Additionally, the nonce of a transaction must not equal or exceed the
105
    limit defined in [EIP-2681].
106
    In practice, defining the limit as ``2**64-1`` has no impact because
107
    sending ``2**64-1`` transactions is improbable. It's not strictly
108
    impossible though, ``2**64-1`` transactions is the entire capacity of the
109
    Ethereum blockchain at 2022 gas limits for a little over 22 years.
110
111
    This function takes a transaction as a parameter and returns the intrinsic
112
    gas cost of the transaction after validation. It throws an
113
    `InvalidTransaction` exception if the transaction is invalid.
114
115
    [EIP-2681]: https://eips.ethereum.org/EIPS/eip-2681
116
    """
117
    intrinsic_gas = calculate_intrinsic_cost(tx)
118
    if intrinsic_gas > tx.gas:
119
        raise InvalidTransaction("Insufficient gas")
120
    if U256(tx.nonce) >= U256(U64.MAX_VALUE):
121
        raise InvalidTransaction("Nonce too high")
122
    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:
126
    """
127
    Calculates the gas that is charged before execution is started.
128
129
    The intrinsic cost of the transaction is charged before execution has
130
    begun. Functions/operations in the EVM cost money to execute so this
131
    intrinsic cost is for the operations that need to be paid for as part of
132
    the transaction. Data transfer, for example, is part of this intrinsic
133
    cost. It costs ether to send data over the wire and that ether is
134
    accounted for in the intrinsic cost calculated in this function. This
135
    intrinsic cost must be calculated and paid for before execution in order
136
    for all operations to be implemented.
137
138
    The intrinsic cost includes:
139
    1. Base cost (`TX_BASE_COST`)
140
    2. Cost for data (zero and non-zero bytes)
141
    3. Cost for contract creation (if applicable)
142
143
    This function takes a transaction as a parameter and returns the intrinsic
144
    gas cost of the transaction.
145
    """
146
    data_cost = Uint(0)
147
148
    for byte in tx.data:
149
        if byte == 0:
150
            data_cost += TX_DATA_COST_PER_ZERO
151
        else:
152
            data_cost += TX_DATA_COST_PER_NON_ZERO
153
154
    if tx.to == Bytes0(b""):
155
        create_cost = TX_CREATE_COST
156
    else:
157
        create_cost = Uint(0)
158
159
    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 a transaction as a parameter 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:
163
    """
164
    Extracts the sender address from a transaction.
165
166
    The v, r, and s values are the three parts that make up the signature
167
    of a transaction. In order to recover the sender of a transaction the two
168
    components needed are the signature (``v``, ``r``, and ``s``) and the
169
    signing hash of the transaction. The sender's public key can be obtained
170
    with these two values and therefore the sender address can be retrieved.
171
172
    This function takes a transaction as a parameter and returns
173
    the address of the sender of the transaction. It raises an
174
    `InvalidSignatureError` if the signature values (r, s, v) are invalid.
175
    """
176
    v, r, s = tx.v, tx.r, tx.s
177
    if v != 27 and v != 28:
178
        raise InvalidSignatureError("bad v")
179
    if U256(0) >= r or r >= SECP256K1N:
180
        raise InvalidSignatureError("bad r")
181
    if U256(0) >= s or s > SECP256K1N // U256(2):
182
        raise InvalidSignatureError("bad s")
183
184
    public_key = secp256k1_recover(r, s, v - U256(27), signing_hash(tx))
185
    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:
189
    """
190
    Compute the hash of a transaction used in the signature.
191
192
    The values that are used to compute the signing hash set the rules for a
193
    transaction. For example, signing over the gas sets a limit for the
194
    amount of money that is allowed to be pulled out of the sender's account.
195
196
    This function takes a transaction as a parameter and returns the
197
    signing hash of the transaction.
198
    """
199
    return keccak256(
200
        rlp.encode(
201
            (
202
                tx.nonce,
203
                tx.gas_price,
204
                tx.gas,
205
                tx.to,
206
                tx.value,
207
                tx.data,
208
            )
209
        )
210
    )

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:
214
    """
215
    Compute the hash of a transaction.
216
217
    This function takes a transaction as a parameter and returns the
218
    hash of the transaction.
219
    """
220
    return keccak256(rlp.encode(tx))