Infinite scrolling with filters and optimistic updates using rtk query

Question

I am using rtk query and have an implementation for infinite scrolling, this logic is implemented through offset and limit, however I also have filters and when changing any of the filters I have to reset the offset to 0.

useEffect(() => {
    setCurrentOffset(0)
}, [status, filter])

I use merge, serializeQueryArgs and forceRefetch. For serializeQueryArgs I use the arguments of this query, excluding the offset and thus when any of the filters change I get a cache update

getShopProducts: build.query<IResponseShopProductData, Partial<IQueryParams>>({
            query: queryParams => {
                const queryString = createQueryParamString(queryParams)
                return `shop-products?${queryString}`
            },
            serializeQueryArgs: ({ queryArgs }) => {
                const newQueryArgs = { ...queryArgs }

                if (newQueryArgs.offset) {
                    delete newQueryArgs.offset
                }

                return queryArgs
            },

            merge: (currentCache, newItems, { arg }) => {
                if (currentCache.results && arg.offset !== 0) {
                    return {
                        ...currentCache,
                        ...newItems,
                        results: [...currentCache.results, ...newItems.results]
                    }
                }

                return newItems
            },
            forceRefetch({ currentArg, previousArg }) {
                return currentArg !== previousArg
            },
            providesTags: result =>
                result
                    ? [
                            ...result.results.map(({ id }) => ({
                                type: 'ShopProducts' as const,
                                id
                            })),
                            'ShopProducts'
                      ]
                    : ['ShopProducts']
})

I also use optimistic updates because the data I display contains the logic of adding to favorites and I want the user to immediately see the result without reloading the entire list and resetting the filters

addWishList: build.mutation<void, IAddWishListData>({
            query: data => ({
                url: `wish-list/`,
                method: 'POST',
                body: data
            }),
            async onQueryStarted({ shop_product }, { dispatch, queryFulfilled }) {
                const patchResult = dispatch(
                    shopProducts.util.updateQueryData('getShopProducts', {}, draft => {
                        const shopProduct = draft.results.find(item => item.id === shop_product)
                        if (shopProduct) shopProduct.in_wish_list = true
                    })
                )

                try {
                    await queryFulfilled
                } catch {
                    patchResult.undo()
                }
            }
})

I'm having a conflict between my two approaches because when I make the query parameters the key for the cache then the key changes dynamically and optimistic updates don't work.

Conversely, if I use a static key for the cache such as endpointName, then resetting the cache when changing filters will not work

serializeQueryArgs: ({ endpointName }) => {
    return endpointName
},

The question is whether it is possible to do what I want and if so, what should be paid attention to?