When trying to link vulkan and glfw on mac osx, i ran this code to test the wether or not everything was working.

my output ->

--- Progress: glfw initialized
--- Progress: glfw supports vulkan
Listing vulkan extension

Available Vulkan extensions:
 - VK_KHR_device_group_creation
 - VK_KHR_external_fence_capabilities
 - VK_KHR_external_memory_capabilities
 - VK_KHR_external_semaphore_capabilities
 - VK_KHR_get_physical_device_properties2
 - VK_KHR_get_surface_capabilities2
 - VK_KHR_surface
 - VK_EXT_debug_report
 - VK_EXT_debug_utils
 - VK_EXT_headless_surface
 - VK_EXT_layer_settings
 - VK_EXT_metal_surface
 - VK_EXT_surface_maintenance1
 - VK_EXT_swapchain_colorspace
 - VK_MVK_macos_surface
 - VK_MVK_moltenvk



Available Vulkan layers / Molten vk support:
 - MoltenVK (MoltenVK driver layer)



glfw Extension -->VK_KHR_surface
glfw Extension -->VK_EXT_metal_surface
Available extensions:
        VK_KHR_device_group_creation
        VK_KHR_external_fence_capabilities
        VK_KHR_external_memory_capabilities
        VK_KHR_external_semaphore_capabilities
        VK_KHR_get_physical_device_properties2
        VK_KHR_get_surface_capabilities2
        VK_KHR_surface
        VK_EXT_debug_report
        VK_EXT_debug_utils
        VK_EXT_headless_surface
        VK_EXT_layer_settings
        VK_EXT_metal_surface
        VK_EXT_surface_maintenance1
        VK_EXT_swapchain_colorspace
        VK_MVK_macos_surface
        VK_MVK_moltenvk
--- Progress: Vulkan instance created
ERROR:             vkGetInstanceProcAddr: Invalid instance [VUID-vkGetInstanceProcAddr-instance-parameter]
zsh: abort      ./PhysicsEngine --testGV

bool TestVulkan_GLFWLinking()
{
    if( !glfwInit() )
    {
        std::cout<<"Error: Couldn't initialize glfwn";
        return false;
    }
    else
    {
        std::cout<<"--- Progress: glfw initializedn";
    }
    glfwSetErrorCallback( error_callback );

    if( !glfwVulkanSupported() )
    {
        std::cout<<"Error: Glfw does not support vulkan";
        return false;
    }
    else
    {
        std::cout<<"--- Progress: glfw supports vulkann";
    }

    std::cout<<"Listing vulkan extensionnn";
    ListVulkanExtensions();
    std::cout<<"nnn";

    PFN_vkCreateInstance PfnCreateInstance = (PFN_vkCreateInstance)
            glfwGetInstanceProcAddress(NULL, "vkCreateInstance");
        std::cout<<"--- Progress: glfw instance procaddress null instancen";

    VkInstance VulkanInstance = CreateVulkanInstance();
    std::cout<<"--- Progress: Vulkan instance createdn";

    PFN_vkCreateInstance pfnCreateDevice = (PFN_vkCreateInstance)
            glfwGetInstanceProcAddress( VulkanInstance, "vkCreateDevice" );
    
    GLFWwindow* GLFWWindow = CreateWindow();
    if( !GLFWWindow )
    {
        std::cout<<"Error: Failed to create glfw window";
        return false;
    }

    VkSurfaceKHR VulkanSurfaceSurface;
    VkResult Error = glfwCreateWindowSurface( VulkanInstance, GLFWWindow, NULL, &VulkanSurfaceSurface );
    if ( Error )
    {
        std::cout<<"Error: Failed to create vulkan window surface";
        return false;
    }

    return true;
}



std::vector<const char*> getRequiredExtensions() 
{
    uint32_t glfwExtensionCount = 0;
    const char** glfwExtensions;

    glfwExtensions = glfwGetRequiredInstanceExtensions(&glfwExtensionCount);

    std::vector<const char*> requiredExtensions;

    requiredExtensions.emplace_back(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME);
    //requiredExtensions.emplace_back( VK_KHR_PORTABILITY_ENUMERATION_EXTENSION_NAME );

    for (uint32_t i = 0; i < glfwExtensionCount; i++) 
    {
        std::cout<<"glfw Extension -->" << glfwExtensions[i]<<"n";
        requiredExtensions.emplace_back(glfwExtensions[i]);
    }
    //requiredExtensions.emplace_back(VK_KHR_surface);
    //requiredExtensions.emplace_back(VK_EXT_metal_surface);

    return requiredExtensions;
}
VkInstance CreateVulkanInstance()
{

    VkApplicationInfo appInfo{};
    appInfo.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
    appInfo.pApplicationName = "Vulkan App";
    appInfo.applicationVersion = VK_MAKE_VERSION(1, 0, 0);
    appInfo.pEngineName = "No Engine";
    appInfo.engineVersion = VK_MAKE_VERSION(1, 0, 0);
    appInfo.apiVersion = VK_API_VERSION_1_0;

    VkInstanceCreateInfo createInfo{};
    createInfo.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
    createInfo.flags |= VK_INSTANCE_CREATE_ENUMERATE_PORTABILITY_BIT_KHR;
    createInfo.pApplicationInfo=&appInfo;
    createInfo.enabledLayerCount = 0;
    createInfo.ppEnabledLayerNames= nullptr;

    VkDebugUtilsMessengerCreateInfoEXT debugCreateInfo{};
    PopulateDebugMessengerCreateInfo(debugCreateInfo);
    createInfo.pNext = (VkDebugUtilsMessengerCreateInfoEXT*) &debugCreateInfo;


    auto requiredExtensions = getRequiredExtensions();
    createInfo.enabledExtensionCount = (uint32_t) requiredExtensions.size(); 
    createInfo.ppEnabledExtensionNames = requiredExtensions.data();
    createInfo.flags |= VK_INSTANCE_CREATE_ENUMERATE_PORTABILITY_BIT_KHR;
    
    std::vector<const char*> deviceExtensions = std::vector<const char*>();
    const char* kPortabilitySubsetExtensionName = "VK_KHR_portability_subset";
    deviceExtensions.emplace_back( kPortabilitySubsetExtensionName );

    VkDeviceQueueCreateInfo QueueInfo;
    VkDeviceCreateInfo DeviceInfo;
    DeviceInfo.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
    DeviceInfo.queueCreateInfoCount = 1;
    DeviceInfo.pQueueCreateInfos=&QueueInfo;
    DeviceInfo.enabledExtensionCount=(uint32_t)deviceExtensions.size();
    DeviceInfo.ppEnabledExtensionNames=deviceExtensions.data();

    VkInstance instance;

    VkResult vkResult = vkCreateInstance(&createInfo, nullptr, &instance);
    if (vkResult != VK_SUCCESS) {
        char* error;
        switch (vkResult) {
            case VK_ERROR_OUT_OF_HOST_MEMORY:
                throw std::runtime_error("Out of memory");
                break;
            case VK_ERROR_OUT_OF_DEVICE_MEMORY: 
                throw std::runtime_error("Out of device memory");
                break;
            case VK_ERROR_INITIALIZATION_FAILED: 
                throw std::runtime_error("Initialization failed");
                break;
            case VK_ERROR_LAYER_NOT_PRESENT: 
                throw std::runtime_error("Layer not present");
                break;
            case VK_ERROR_EXTENSION_NOT_PRESENT: 
                throw std::runtime_error("Extension not present");
                break;
            case VK_ERROR_INCOMPATIBLE_DRIVER: 
                throw std::runtime_error("Incompatible driver");
                break;
            default: 
                throw std::runtime_error("Unknown error");
                break;
        }
    }

    uint32_t extensionCount = 0;
    vkEnumerateInstanceExtensionProperties(nullptr, &extensionCount, nullptr);

    std::vector<VkExtensionProperties> extensions(extensionCount);
    vkEnumerateInstanceExtensionProperties(nullptr, &extensionCount, extensions.data());

    std::cout << "Available extensions:" << std::endl;
    for (const auto& extension : extensions) {
        std::cout << "t" << extension.extensionName << std::endl;
    }

    return instance;
}
GLFWwindow* CreateWindow()
{
    glfwWindowHint( GLFW_CLIENT_API, GLFW_NO_API );
    glfwWindowHint( GLFW_RESIZABLE, GLFW_TRUE );
    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
    GLFWwindow* window = glfwCreateWindow( 1280, 720, "Window", glfwGetPrimaryMonitor(), nullptr );

    return window;
}

where my code crashes –>

GLFWAPI GLFWvkproc glfwGetInstanceProcAddress(VkInstance instance,
                                              const char* procname)
{
    GLFWvkproc proc;
    assert(procname != NULL);

    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);

    if (!_glfwInitVulkan(_GLFW_REQUIRE_LOADER))
        return NULL;

    // NOTE: Vulkan 1.0 and 1.1 vkGetInstanceProcAddr cannot return itself
    if (strcmp(procname, "vkGetInstanceProcAddr") == 0)
        return (GLFWvkproc) vkGetInstanceProcAddr;

    proc = (GLFWvkproc) vkGetInstanceProcAddr(instance, procname);//Line of crash
    if (!proc)
    {
        if (_glfw.vk.handle)
            proc = (GLFWvkproc) _glfwPlatformGetModuleSymbol(_glfw.vk.handle, procname);
    }

    return proc;
}

I have tried manually adding different extensions, but from what i know all the required extensions are already there.
I tried first creating a PFN_vkCreateInstance pfnCreateDevice and PFN_vkCreateInstance PfnCreateInstance but these get the same errors