ethereum.berlin.fork_types

  1"""
  2Ethereum Types
  3^^^^^^^^^^^^^^
  4
  5.. contents:: Table of Contents
  6    :backlinks: none
  7    :local:
  8
  9Introduction
 10------------
 11
 12Types re-used throughout the specification, which are specific to Ethereum.
 13"""
 14
 15from dataclasses import dataclass
 16from typing import Tuple, Union
 17
 18from .. import rlp
 19from ..base_types import (
 20    U64,
 21    U256,
 22    Bytes,
 23    Bytes0,
 24    Bytes8,
 25    Bytes20,
 26    Bytes32,
 27    Bytes256,
 28    Uint,
 29    slotted_freezable,
 30)
 31from ..crypto.hash import Hash32, keccak256
 32from ..exceptions import InvalidBlock
 33from ..utils.ensure import ensure
 34
 35Address = Bytes20
 36Root = Hash32
 37
 38Bloom = Bytes256
 39
 40TX_BASE_COST = 21000
 41TX_DATA_COST_PER_NON_ZERO = 16
 42TX_DATA_COST_PER_ZERO = 4
 43TX_CREATE_COST = 32000
 44TX_ACCESS_LIST_ADDRESS_COST = 2400
 45TX_ACCESS_LIST_STORAGE_KEY_COST = 1900
 46
 47
 48@slotted_freezable
 49@dataclass
 50class LegacyTransaction:
 51    """
 52    Atomic operation performed on the block chain.
 53    """
 54
 55    nonce: U256
 56    gas_price: Uint
 57    gas: Uint
 58    to: Union[Bytes0, Address]
 59    value: U256
 60    data: Bytes
 61    v: U256
 62    r: U256
 63    s: U256
 64
 65
 66@slotted_freezable
 67@dataclass
 68class AccessListTransaction:
 69    """
 70    The transaction type added in EIP-2930 to support access lists.
 71    """
 72
 73    chain_id: U64
 74    nonce: U256
 75    gas_price: Uint
 76    gas: Uint
 77    to: Union[Bytes0, Address]
 78    value: U256
 79    data: Bytes
 80    access_list: Tuple[Tuple[Address, Tuple[Bytes32, ...]], ...]
 81    y_parity: U256
 82    r: U256
 83    s: U256
 84
 85
 86Transaction = Union[LegacyTransaction, AccessListTransaction]
 87
 88
 89def encode_transaction(tx: Transaction) -> Union[LegacyTransaction, Bytes]:
 90    """
 91    Encode a transaction. Needed because non-legacy transactions aren't RLP.
 92    """
 93    if isinstance(tx, LegacyTransaction):
 94        return tx
 95    elif isinstance(tx, AccessListTransaction):
 96        return b"\x01" + rlp.encode(tx)
 97    else:
 98        raise Exception(f"Unable to encode transaction of type {type(tx)}")
 99
100
101def decode_transaction(tx: Union[LegacyTransaction, Bytes]) -> Transaction:
102    """
103    Decode a transaction. Needed because non-legacy transactions aren't RLP.
104    """
105    if isinstance(tx, Bytes):
106        ensure(tx[0] == 1, InvalidBlock)
107        return rlp.decode_to(AccessListTransaction, tx[1:])
108    else:
109        return tx
110
111
112@slotted_freezable
113@dataclass
114class Account:
115    """
116    State associated with an address.
117    """
118
119    nonce: Uint
120    balance: U256
121    code: bytes
122
123
124EMPTY_ACCOUNT = Account(
125    nonce=Uint(0),
126    balance=U256(0),
127    code=bytearray(),
128)
129
130
131def encode_account(raw_account_data: Account, storage_root: Bytes) -> Bytes:
132    """
133    Encode `Account` dataclass.
134
135    Storage is not stored in the `Account` dataclass, so `Accounts` cannot be
136    encoded with providing a storage root.
137    """
138    return rlp.encode(
139        (
140            raw_account_data.nonce,
141            raw_account_data.balance,
142            storage_root,
143            keccak256(raw_account_data.code),
144        )
145    )
146
147
148@slotted_freezable
149@dataclass
150class Header:
151    """
152    Header portion of a block on the chain.
153    """
154
155    parent_hash: Hash32
156    ommers_hash: Hash32
157    coinbase: Address
158    state_root: Root
159    transactions_root: Root
160    receipt_root: Root
161    bloom: Bloom
162    difficulty: Uint
163    number: Uint
164    gas_limit: Uint
165    gas_used: Uint
166    timestamp: U256
167    extra_data: Bytes
168    mix_digest: Bytes32
169    nonce: Bytes8
170
171
172@slotted_freezable
173@dataclass
174class Block:
175    """
176    A complete block.
177    """
178
179    header: Header
180    transactions: Tuple[Union[Bytes, LegacyTransaction], ...]
181    ommers: Tuple[Header, ...]
182
183
184@slotted_freezable
185@dataclass
186class Log:
187    """
188    Data record produced during the execution of a transaction.
189    """
190
191    address: Address
192    topics: Tuple[Hash32, ...]
193    data: bytes
194
195
196@slotted_freezable
197@dataclass
198class Receipt:
199    """
200    Result of a transaction.
201    """
202
203    succeeded: bool
204    cumulative_gas_used: Uint
205    bloom: Bloom
206    logs: Tuple[Log, ...]