<snip>

    return (

        len(code) == EOA_DELEGATED_CODE_LENGTH

        and code[:EOA_DELEGATION_MARKER_LENGTH] == EOA_DELEGATION_MARKER

    )

    <snip>

    if is_valid_delegation(code):

        return Address(code[EOA_DELEGATION_MARKER_LENGTH:])

    return None

    <snip>

    y_parity, r, s = authorization.y_parity, authorization.r, authorization.s

    if y_parity not in (0, 1):

        raise InvalidSignatureError("Invalid y_parity in authorization")

    if U256(0) >= r or r >= SECP256K1N:

        raise InvalidSignatureError("Invalid r value in authorization")

    if U256(0) >= s or s > SECP256K1N // U256(2):

        raise InvalidSignatureError("Invalid s value in authorization")

    signing_hash = keccak256(

        SET_CODE_TX_MAGIC

        + rlp.encode(

            (

                authorization.chain_id,

                authorization.address,

                authorization.nonce,

            )

        )

    )

    public_key = secp256k1_recover(r, s, U256(y_parity), signing_hash)

    return Address(keccak256(public_key)[12:32])

    <snip>

    tx_state = evm.message.tx_env.state

    code = get_code(tx_state, get_account(tx_state, address).code_hash)

    if not is_valid_delegation(code):

        return False, address, Uint(0)

    delegated_address = Address(code[EOA_DELEGATION_MARKER_LENGTH:])

    if delegated_address in evm.accessed_addresses:

        delegation_gas_cost = GasCosts.WARM_ACCESS

    else:

        delegation_gas_cost = GasCosts.COLD_ACCOUNT_ACCESS

    return True, delegated_address, delegation_gas_cost

    <snip>

    tx_state = message.tx_env.state

    if auth.chain_id not in (message.block_env.chain_id, U256(0)):

        return None

    if auth.nonce >= U64.MAX_VALUE:

        return None

    try:

        authority = recover_authority(auth)

    except InvalidSignatureError:

        return None

    message.accessed_addresses.add(authority)

    authority_account = get_account(tx_state, authority)

    authority_code = get_code(tx_state, authority_account.code_hash)

    if authority_code and not is_valid_delegation(authority_code):

        return None

    authority_nonce = authority_account.nonce

    if authority_nonce != auth.nonce:

        return None

    return (authority, authority_code)

    <snip>

    tx_state = message.tx_env.state

    state_refund = Uint(0)

    regular_refund = Uint(0)

    for auth in message.tx_env.authorizations:

        match validate_authorization(message, auth):

            case None:

                refund = StateGasCosts.AUTH_BASE + StateGasCosts.NEW_ACCOUNT

                message.state_gas_reservoir += refund

                state_refund += refund

                regular_refund += GasCosts.ACCOUNT_WRITE

                continue

            case (authority, authority_code):

                pass

        refund = StateGas(Uint(0))

        if account_exists(tx_state, authority):

            refund += StateGasCosts.NEW_ACCOUNT

            # The new-account ACCOUNT_WRITE charged at intrinsic time is

            # not needed: refund it to the regular refund counter.

            regular_refund += GasCosts.ACCOUNT_WRITE

        pre_state_authority_account = get_pre_state_account(

            tx_state, authority

        )

        pre_state_authority_code = get_code(

            tx_state, pre_state_authority_account.code_hash

        )

        delegated_before_tx = is_valid_delegation(pre_state_authority_code)

        delegated_now = is_valid_delegation(authority_code)

        if auth.address == NULL_ADDRESS:

            refund += StateGasCosts.AUTH_BASE

            if delegated_now and not delegated_before_tx:

                refund += StateGasCosts.AUTH_BASE

            code_to_set = b""

        else:

            code_to_set = EOA_DELEGATION_MARKER + auth.address

            if delegated_now or delegated_before_tx:

                refund += StateGasCosts.AUTH_BASE

        set_code(tx_state, authority, code_to_set)

        increment_nonce(tx_state, authority)

        message.state_gas_reservoir += refund

        state_refund += refund

    if message.code_address is None:

        raise InvalidBlock("Invalid type 4 transaction: no target")

    message.code = get_code(

        tx_state,

        get_account(tx_state, message.code_address).code_hash,

    )

    return state_refund, regular_refund