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 | if ( |
| 54 | len(code) == EOA_DELEGATED_CODE_LENGTH |
| 55 | and code[:EOA_DELEGATION_MARKER_LENGTH] == EOA_DELEGATION_MARKER |
| 56 | ): |
| 57 | return True |
| 58 | return False |
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]:
| 62 | <snip> |
|---|---|
| 76 | if is_valid_delegation(code): |
| 77 | return Address(code[EOA_DELEGATION_MARKER_LENGTH:]) |
| 78 | 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]:
| 126 | <snip> |
|---|---|
| 142 | tx_state = evm.message.tx_env.state |
| 143 | code = get_code(tx_state, get_account(tx_state, address).code_hash) |
| 144 | if not is_valid_delegation(code): |
| 145 | return False, address, code, Uint(0) |
| 146 | |
| 147 | address = Address(code[EOA_DELEGATION_MARKER_LENGTH:]) |
| 148 | if address in evm.accessed_addresses: |
| 149 | access_gas_cost = GasCosts.WARM_ACCESS |
| 150 | else: |
| 151 | evm.accessed_addresses.add(address) |
| 152 | access_gas_cost = GasCosts.COLD_ACCOUNT_ACCESS |
| 153 | code = get_code(tx_state, get_account(tx_state, address).code_hash) |
| 154 | |
| 155 | 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]:
| 127 | <snip> |
|---|---|
| 143 | tx_state = evm.message.tx_env.state |
| 144 | |
| 145 | code = get_code(tx_state, get_account(tx_state, address).code_hash) |
| 146 | |
| 147 | if not is_valid_delegation(code): |
| 148 | return False, address, Uint(0) |
| 149 | |
| 150 | delegated_address = Address(code[EOA_DELEGATION_MARKER_LENGTH:]) |
| 151 | |
| 152 | if delegated_address in evm.accessed_addresses: |
| 153 | delegation_gas_cost = GasCosts.WARM_ACCESS |
| 154 | else: |
| 155 | delegation_gas_cost = GasCosts.COLD_ACCOUNT_ACCESS |
| 156 | |
| 157 | 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:
| 161 | <snip> |
|---|---|
| 180 | tx_state = message.tx_env.state |
| 174 | refund_counter = U256(0) |
| 181 | state_refund = Uint(0) |
| 182 | for auth in message.tx_env.authorizations: |
| 183 | if auth.chain_id not in (message.block_env.chain_id, U256(0)): |
| 184 | continue |
| 185 | |
| 186 | if auth.nonce >= U64.MAX_VALUE: |
| 187 | continue |
| 188 | |
| 189 | try: |
| 190 | authority = recover_authority(auth) |
| 191 | except InvalidSignatureError: |
| 192 | continue |
| 193 | |
| 194 | message.accessed_addresses.add(authority) |
| 195 | |
| 196 | authority_account = get_account(tx_state, authority) |
| 197 | authority_code = get_code(tx_state, authority_account.code_hash) |
| 198 | |
| 199 | if authority_code and not is_valid_delegation(authority_code): |
| 200 | continue |
| 201 | |
| 202 | authority_nonce = authority_account.nonce |
| 203 | if authority_nonce != auth.nonce: |
| 204 | continue |
| 205 | |
| 206 | if account_exists(tx_state, authority): |
| 200 | refund_counter += U256( |
| 201 | GasCosts.AUTH_PER_EMPTY_ACCOUNT |
| 202 | - REFUND_AUTH_PER_EXISTING_ACCOUNT |
| 203 | ) |
| 207 | refund = StateGasCosts.NEW_ACCOUNT |
| 208 | message.state_gas_reservoir += refund |
| 209 | state_refund += refund |
| 210 | |
| 211 | # No new delegation indicator bytes are written: either the |
| 212 | # authority already has one (overwrite in place / clear) or |
| 213 | # this auth clears against an authority with no prior code. |
| 214 | if ( |
| 215 | authority_account.code_hash != EMPTY_CODE_HASH |
| 216 | or auth.address == NULL_ADDRESS |
| 217 | ): |
| 218 | refund = StateGasCosts.AUTH_BASE |
| 219 | message.state_gas_reservoir += refund |
| 220 | state_refund += refund |
| 221 | |
| 222 | if auth.address == NULL_ADDRESS: |
| 223 | code_to_set = b"" |
| 224 | else: |
| 225 | code_to_set = EOA_DELEGATION_MARKER + auth.address |
| 226 | |
| 227 | set_code(tx_state, authority, code_to_set) |
| 210 | |
| 228 | increment_nonce(tx_state, authority) |
| 229 | |
| 230 | if message.code_address is None: |
| 231 | raise InvalidBlock("Invalid type 4 transaction: no target") |
| 232 | |
| 233 | message.code = get_code( |
| 217 | tx_state, get_account(tx_state, message.code_address).code_hash |
| 234 | tx_state, |
| 235 | get_account(tx_state, message.code_address).code_hash, |
| 236 | ) |
| 237 | |
| 220 | return refund_counter |
| 238 | return state_refund |