ethereum.forks.bpo5.vm.eoa_delegationethereum.forks.amsterdam.vm.eoa_delegation
Set EOA account code.
SET_CODE_TX_MAGIC¶
| 30 | SET_CODE_TX_MAGIC = b"\x05" |
|---|
EOA_DELEGATION_MARKER¶
| 31 | EOA_DELEGATION_MARKER = b"\xef\x01\x00" |
|---|
EOA_DELEGATION_MARKER_LENGTH¶
| 32 | EOA_DELEGATION_MARKER_LENGTH = len(EOA_DELEGATION_MARKER) |
|---|
EOA_DELEGATED_CODE_LENGTH¶
| 33 | EOA_DELEGATED_CODE_LENGTH = 23 |
|---|
REFUND_AUTH_PER_EXISTING_ACCOUNT¶
| 32 | REFUND_AUTH_PER_EXISTING_ACCOUNT = 12500 |
|---|
NULL_ADDRESS¶
| 34 | 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:
| 38 | <snip> |
|---|---|
| 53 | return ( |
| 54 | len(code) == EOA_DELEGATED_CODE_LENGTH |
| 55 | and code[:EOA_DELEGATION_MARKER_LENGTH] == EOA_DELEGATION_MARKER |
| 56 | ) |
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]:
| 60 | <snip> |
|---|---|
| 74 | if is_valid_delegation(code): |
| 75 | return Address(code[EOA_DELEGATION_MARKER_LENGTH:]) |
| 76 | return None |
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 |
calculate_delegation_cost ¶
Get the delegation address and the cost of access from the address.
Parameters
evm : Evm
The execution frame.
address : Address
The address to check for delegation.
Returns
delegation : Tuple[bool, Address, Uint]
The delegation address and access gas cost.
def calculate_delegation_cost(evm: Evm, address: Address) -> Tuple[bool, Address, Uint]:
| 125 | <snip> |
|---|---|
| 141 | tx_state = evm.message.tx_env.state |
| 142 | |
| 143 | code = get_code(tx_state, get_account(tx_state, address).code_hash) |
| 144 | |
| 145 | if not is_valid_delegation(code): |
| 146 | return False, address, Uint(0) |
| 147 | |
| 148 | delegated_address = Address(code[EOA_DELEGATION_MARKER_LENGTH:]) |
| 149 | |
| 150 | if delegated_address in evm.accessed_addresses: |
| 151 | delegation_gas_cost = GasCosts.WARM_ACCESS |
| 152 | else: |
| 153 | delegation_gas_cost = GasCosts.COLD_ACCOUNT_ACCESS |
| 154 | |
| 155 | return True, delegated_address, delegation_gas_cost |
set_delegation ¶
Set the delegation code for the authorities in the message.
Refills StateGasCosts.NEW_ACCOUNT when the authority's account
leaf already exists, and StateGasCosts.AUTH_BASE when its code
slot already holds a delegation indicator. The total is returned
so block accounting can subtract it from tx_state_gas.
Parameters
message : Transaction specific items.
Returns
refund_counter: state_refund : U256UintRefund from authority which already exists in state.Total state gas refunded across all processed authorizations.
def set_delegation(message: Message) -> U256Uint:
| 196 | <snip> |
|---|---|
| 215 | tx_state = message.tx_env.state |
| 209 | refund_counter = U256(0) |
| 216 | state_refund = Uint(0) |
| 217 | for auth in message.tx_env.authorizations: |
| 218 | match validate_authorization(message, auth): |
| 219 | case None: |
| 220 | continue |
| 214 | case authority: |
| 221 | case (authority, authority_account): |
| 222 | pass |
| 223 | |
| 224 | if account_exists(tx_state, authority): |
| 218 | refund_counter += U256( |
| 219 | GasCosts.AUTH_PER_EMPTY_ACCOUNT |
| 220 | - REFUND_AUTH_PER_EXISTING_ACCOUNT |
| 221 | ) |
| 225 | refund = StateGasCosts.NEW_ACCOUNT |
| 226 | message.state_gas_reservoir += refund |
| 227 | state_refund += refund |
| 228 | |
| 229 | # No new delegation indicator bytes are written: either the |
| 230 | # authority already has one (overwrite in place / clear) or |
| 231 | # this auth clears against an authority with no prior code. |
| 232 | if ( |
| 233 | authority_account.code_hash != EMPTY_CODE_HASH |
| 234 | or auth.address == NULL_ADDRESS |
| 235 | ): |
| 236 | refund = StateGasCosts.AUTH_BASE |
| 237 | message.state_gas_reservoir += refund |
| 238 | state_refund += refund |
| 239 | |
| 240 | if auth.address == NULL_ADDRESS: |
| 241 | code_to_set = b"" |
| 242 | else: |
| 243 | code_to_set = EOA_DELEGATION_MARKER + auth.address |
| 244 | |
| 245 | set_code(tx_state, authority, code_to_set) |
| 228 | |
| 246 | increment_nonce(tx_state, authority) |
| 247 | |
| 248 | if message.code_address is None: |
| 249 | raise InvalidBlock("Invalid type 4 transaction: no target") |
| 250 | |
| 251 | message.code = get_code( |
| 235 | tx_state, get_account(tx_state, message.code_address).code_hash |
| 252 | tx_state, |
| 253 | get_account(tx_state, message.code_address).code_hash, |
| 254 | ) |
| 255 | |
| 238 | return refund_counter |
| 256 | return state_refund |