ethereum.forks.bpo1.vm.eoa_delegationethereum.forks.bpo2.vm.eoa_delegation

Set EOA account code.

SET_CODE_TX_MAGIC

28
SET_CODE_TX_MAGIC = b"\x05"

EOA_DELEGATION_MARKER

29
EOA_DELEGATION_MARKER = b"\xef\x01\x00"

EOA_DELEGATION_MARKER_LENGTH

30
EOA_DELEGATION_MARKER_LENGTH = len(EOA_DELEGATION_MARKER)

EOA_DELEGATED_CODE_LENGTH

31
EOA_DELEGATED_CODE_LENGTH = 23

REFUND_AUTH_PER_EXISTING_ACCOUNT

32
REFUND_AUTH_PER_EXISTING_ACCOUNT = 12500

NULL_ADDRESS

33
NULL_ADDRESS = hex_to_address("0x0000000000000000000000000000000000000000")

is_valid_delegation

Whether the code is a valid delegation designation.

Parameters

code: bytes The code to check.

Returns

valid : bool True if the code is a valid delegation designation, False otherwise.

def is_valid_delegation(​code: bytes​) -> bool:
37
    <snip>
52
    return (
53
        len(code) == EOA_DELEGATED_CODE_LENGTH
54
        and code[:EOA_DELEGATION_MARKER_LENGTH] == EOA_DELEGATION_MARKER
55
    )

get_delegated_code_address

Get the address to which the code delegates.

Parameters

code: bytes The code to get the address from.

Returns

address : Optional[Address] The address of the delegated code.

def get_delegated_code_address(​code: bytes​) -> Optional[Address]:
59
    <snip>
73
    if is_valid_delegation(code):
74
        return Address(code[EOA_DELEGATION_MARKER_LENGTH:])
75
    return None

recover_authority

Recover the authority address from the authorization.

Parameters

authorization The authorization to recover the authority from.

Raises

InvalidSignatureError If the signature is invalid.

Returns

authority : Address The recovered authority address.

def recover_authority(​authorization: Authorization​) -> Address:
79
    <snip>
98
    y_parity, r, s = authorization.y_parity, authorization.r, authorization.s
99
    if y_parity not in (0, 1):
100
        raise InvalidSignatureError("Invalid y_parity in authorization")
101
    if U256(0) >= r or r >= SECP256K1N:
102
        raise InvalidSignatureError("Invalid r value in authorization")
103
    if U256(0) >= s or s > SECP256K1N // U256(2):
104
        raise InvalidSignatureError("Invalid s value in authorization")
105
106
    signing_hash = keccak256(
107
        SET_CODE_TX_MAGIC
108
        + rlp.encode(
109
            (
110
                authorization.chain_id,
111
                authorization.address,
112
                authorization.nonce,
113
            )
114
        )
115
    )
116
117
    public_key = secp256k1_recover(r, s, U256(y_parity), signing_hash)
118
    return Address(keccak256(public_key)[12:32])

access_delegation

Get the delegation address, code, and the cost of access from the address.

Parameters

evm : Evm The execution frame. address : Address The address to get the delegation from.

Returns

delegation : Tuple[bool, Address, Bytes, Uint] The delegation address, code, and access gas cost.

def access_delegation(​evm: Evm, ​​address: Address​) -> Tuple[bool, Address, Bytes, Uint]:
124
    <snip>
140
    tx_state = evm.message.tx_env.state
141
    code = get_code(tx_state, get_account(tx_state, address).code_hash)
142
    if not is_valid_delegation(code):
143
        return False, address, code, Uint(0)
144
145
    address = Address(code[EOA_DELEGATION_MARKER_LENGTH:])
146
    if address in evm.accessed_addresses:
147
        access_gas_cost = GasCosts.WARM_ACCESS
148
    else:
149
        evm.accessed_addresses.add(address)
150
        access_gas_cost = GasCosts.COLD_ACCOUNT_ACCESS
151
    code = get_code(tx_state, get_account(tx_state, address).code_hash)
152
153
    return True, address, code, access_gas_cost

validate_authorization

Check if the given Authorization is valid against the current state.

Returns the authority address or None if the validation was unsuccessful.

def validate_authorization(​message: Message, ​​auth: Authorization​) -> None | Address:
159
    <snip>
165
    tx_state = message.tx_env.state
166
167
    if auth.chain_id not in (message.block_env.chain_id, U256(0)):
168
        return None
169
170
    if auth.nonce >= U64.MAX_VALUE:
171
        return None
172
173
    try:
174
        authority = recover_authority(auth)
175
    except InvalidSignatureError:
176
        return None
177
178
    message.accessed_addresses.add(authority)
179
180
    authority_account = get_account(tx_state, authority)
181
    authority_code = get_code(tx_state, authority_account.code_hash)
182
183
    if authority_code and not is_valid_delegation(authority_code):
184
        return None
185
186
    authority_nonce = authority_account.nonce
187
    if authority_nonce != auth.nonce:
188
        return None
189
190
    return authority

set_delegation

Set the delegation code for the authorities in the message.

Parameters

message : Transaction specific items.

Returns

refund_counter: U256 Refund from authority which already exists in state.

def set_delegation(​message: Message​) -> U256:
194
    <snip>
208
    tx_state = message.tx_env.state
209
    refund_counter = U256(0)
210
    for auth in message.tx_env.authorizations:
211
        match validate_authorization(message, auth):
212
            case None:
213
                continue
214
            case authority:
215
                pass
216
217
        if account_exists(tx_state, authority):
218
            refund_counter += U256(
219
                GasCosts.AUTH_PER_EMPTY_ACCOUNT
220
                - REFUND_AUTH_PER_EXISTING_ACCOUNT
221
            )
222
223
        if auth.address == NULL_ADDRESS:
224
            code_to_set = b""
225
        else:
226
            code_to_set = EOA_DELEGATION_MARKER + auth.address
227
        set_code(tx_state, authority, code_to_set)
228
229
        increment_nonce(tx_state, authority)
230
231
    if message.code_address is None:
232
        raise InvalidBlock("Invalid type 4 transaction: no target")
233
234
    message.code = get_code(
235
        tx_state, get_account(tx_state, message.code_address).code_hash
236
    )
237
238
    return refund_counter