@0xsequence/marketplace-sdk 1.2.1 → 2.0.1

package/src/react/hooks/{data/orders/useFloorOrder.test.tsx → collection/market-floor.test.tsx}

@@ -1,23 +1,23 @@
+import * as MarketplaceMocks from '@0xsequence/api-client/mocks/marketplace';
+
+const { mockCollectibleOrder, mockMarketplaceEndpoint } = MarketplaceMocks;
+
 import { renderHook, server, waitFor } from '@test';
 import { HttpResponse, http } from 'msw';
 import { zeroAddress } from 'viem';
 import { describe, expect, it } from 'vitest';
-import {
-	mockCollectibleOrder,
-	mockMarketplaceEndpoint,
-} from '../../../_internal/api/__mocks__/marketplace.msw';
-import type { UseFloorOrderParams } from './useFloorOrder';
-import { useFloorOrder } from './useFloorOrder';
-
-describe('useFloorOrder', () => {
-	const defaultArgs: UseFloorOrderParams = {
+import type { UseCollectionMarketFloorParams } from './market-floor';
+import { useCollectionMarketFloor } from './market-floor';
+
+describe('useCollectionMarketFloor', () => {
+	const defaultArgs: UseCollectionMarketFloorParams = {
 		chainId: 1,
 		collectionAddress: zeroAddress,
 		query: {},
 	};
 
 	it('should fetch floor order data successfully', async () => {
-		const { result } = renderHook(() => useFloorOrder(defaultArgs));
+		const { result } = renderHook(() => useCollectionMarketFloor(defaultArgs));
 
 		// Initially loading
 		expect(result.current.isLoading).toBe(true);
@@ -44,7 +44,7 @@ describe('useFloorOrder', () => {
 			}),
 		);
 
-		const { result } = renderHook(() => useFloorOrder(defaultArgs));
+		const { result } = renderHook(() => useCollectionMarketFloor(defaultArgs));
 
 		await waitFor(() => {
 			expect(result.current.isError).toBe(true);
@@ -55,7 +55,9 @@ describe('useFloorOrder', () => {
 	});
 
 	it('should refetch when args change', async () => {
-		const { result, rerender } = renderHook(() => useFloorOrder(defaultArgs));
+		const { result, rerender } = renderHook(() =>
+			useCollectionMarketFloor(defaultArgs),
+		);
 
 		// Wait for initial data
 		await waitFor(() => {
@@ -69,7 +71,7 @@ describe('useFloorOrder', () => {
 				'0x1234567890123456789012345678901234567890' as `0x${string}`,
 		};
 
-		rerender(() => useFloorOrder(newArgs));
+		rerender(() => useCollectionMarketFloor(newArgs));
 
 		// Wait for new data
 		await waitFor(() => {
@@ -82,13 +84,15 @@ describe('useFloorOrder', () => {
 	});
 
 	it('should handle undefined query params', async () => {
-		const argsWithoutQuery: UseFloorOrderParams = {
+		const argsWithoutQuery: UseCollectionMarketFloorParams = {
 			chainId: 1,
 			collectionAddress: zeroAddress,
 			query: {},
 		};
 
-		const { result } = renderHook(() => useFloorOrder(argsWithoutQuery));
+		const { result } = renderHook(() =>
+			useCollectionMarketFloor(argsWithoutQuery),
+		);
 
 		await waitFor(() => {
 			expect(result.current.isLoading).toBe(false);

package/src/react/hooks/{data/orders/useFloorOrder.tsx → collection/market-floor.tsx}

@@ -1,15 +1,17 @@
 'use client';
 
 import { useQuery } from '@tanstack/react-query';
-import type { Optional } from '../../../_internal';
+import type { Optional, WithRequired } from '../../_internal';
 import {
-	type FetchFloorOrderParams,
 	type FloorOrderQueryOptions,
 	floorOrderQueryOptions,
-} from '../../../queries/orders/floorOrder';
-import { useConfig } from '../../config/useConfig';
+} from '../../queries/collection/market-floor';
+import { useConfig } from '../config/useConfig';
 
-export type UseFloorOrderParams = Optional<FloorOrderQueryOptions, 'config'>;
+export type UseCollectionMarketFloorParams = Optional<
+	WithRequired<FloorOrderQueryOptions, 'chainId' | 'collectionAddress'>,
+	'config'
+>;
 
 /**
  * Hook to fetch the floor order for a collection
@@ -28,7 +30,7 @@ export type UseFloorOrderParams = Optional<FloorOrderQueryOptions, 'config'>;
  * @example
  * Basic usage:
  * ```typescript
- * const { data, isLoading } = useFloorOrder({
+ * const { data, isLoading } = useCollectionMarketFloor({
  *   chainId: 137,
  *   collectionAddress: '0x...'
  * })
@@ -37,7 +39,7 @@ export type UseFloorOrderParams = Optional<FloorOrderQueryOptions, 'config'>;
  * @example
  * With filters and custom query options:
  * ```typescript
- * const { data, isLoading } = useFloorOrder({
+ * const { data, isLoading } = useCollectionMarketFloor({
  *   chainId: 1,
  *   collectionAddress: '0x...',
  *   filter: {
@@ -50,7 +52,9 @@ export type UseFloorOrderParams = Optional<FloorOrderQueryOptions, 'config'>;
  * })
  * ```
  */
-export function useFloorOrder(params: UseFloorOrderParams) {
+export function useCollectionMarketFloor(
+	params: UseCollectionMarketFloorParams,
+) {
 	const defaultConfig = useConfig();
 
 	const { config = defaultConfig, ...rest } = params;
@@ -67,4 +71,4 @@ export function useFloorOrder(params: UseFloorOrderParams) {
 
 export { floorOrderQueryOptions };
 
-export type { FetchFloorOrderParams, FloorOrderQueryOptions };
+export type { FloorOrderQueryOptions };

package/src/react/hooks/collection/market-items-count.test.tsx

@@ -0,0 +1,121 @@
+import { OrderSide } from '@0xsequence/api-client';
+import * as MarketplaceMocks from '@0xsequence/api-client/mocks/marketplace';
+import { renderHook, server, waitFor } from '@test';
+import { HttpResponse, http } from 'msw';
+import { zeroAddress } from 'viem';
+import { describe, expect, it } from 'vitest';
+import type { UseCollectionMarketItemsCountParams } from './market-items-count';
+import { useCollectionMarketItemsCount } from './market-items-count';
+
+const { mockMarketplaceEndpoint } = MarketplaceMocks;
+
+describe('useCollectionMarketItemsCount', () => {
+	const defaultArgs: UseCollectionMarketItemsCountParams = {
+		chainId: 1,
+		collectionAddress: zeroAddress,
+		side: OrderSide.listing,
+	};
+
+	it('should fetch orders count successfully', async () => {
+		const mockCount = 100;
+
+		server.use(
+			http.post(mockMarketplaceEndpoint('GetCountOfAllOrders'), () => {
+				return HttpResponse.json({ count: mockCount });
+			}),
+		);
+
+		const { result } = renderHook(() =>
+			useCollectionMarketItemsCount(defaultArgs),
+		);
+
+		// Initially loading
+		expect(result.current.isLoading).toBe(true);
+		expect(result.current.data).toBeUndefined();
+
+		// Wait for data to be loaded
+		await waitFor(() => {
+			expect(result.current.isLoading).toBe(false);
+		});
+
+		// Verify the data matches our mock
+		expect(result.current.data).toBe(mockCount);
+		expect(result.current.error).toBeNull();
+	});
+
+	it('should handle error states', async () => {
+		// Override the handler for this test to return an error
+		server.use(
+			http.post(mockMarketplaceEndpoint('GetCountOfAllOrders'), () => {
+				return HttpResponse.json(
+					{ error: { message: 'Failed to fetch count' } },
+					{ status: 500 },
+				);
+			}),
+		);
+
+		const { result } = renderHook(() =>
+			useCollectionMarketItemsCount(defaultArgs),
+		);
+
+		await waitFor(() => {
+			expect(result.current.isError).toBe(true);
+		});
+
+		expect(result.current.error).toBeDefined();
+		expect(result.current.data).toBeUndefined();
+	});
+
+	it('should refetch when args change', async () => {
+		const mockCount1 = 50;
+		const mockCount2 = 75;
+
+		let callCount = 0;
+		server.use(
+			http.post(mockMarketplaceEndpoint('GetCountOfAllOrders'), () => {
+				callCount++;
+				return HttpResponse.json({
+					count: callCount === 1 ? mockCount1 : mockCount2,
+				});
+			}),
+		);
+
+		const { result, rerender } = renderHook(
+			(args: UseCollectionMarketItemsCountParams = defaultArgs) =>
+				useCollectionMarketItemsCount(args),
+		);
+
+		// Wait for initial data
+		await waitFor(() => {
+			expect(result.current.data).toBe(mockCount1);
+		});
+
+		// Change args and rerender
+		const newArgs = {
+			...defaultArgs,
+			side: OrderSide.offer,
+		};
+
+		rerender(newArgs);
+
+		// Wait for new data
+		await waitFor(() => {
+			expect(result.current.data).toBe(mockCount2);
+		});
+	});
+
+	it('should not fetch if required params are missing', async () => {
+		const { result } = renderHook(() =>
+			useCollectionMarketItemsCount({
+				...defaultArgs,
+				chainId: undefined,
+			} as any),
+		);
+
+		// In TanStack Query v5, disabled queries start in 'pending' state but isLoading is false (if using useQuery)
+		// However, the exact behavior depends on the version.
+		// Based on market-filtered-count.test.tsx, we check isLoading is false.
+		expect(result.current.isLoading).toBe(false);
+		expect(result.current.data).toBeUndefined();
+	});
+});

package/src/react/hooks/{data/orders/useCountItemsOrdersForCollection.tsx → collection/market-items-count.tsx}

@@ -1,15 +1,15 @@
 'use client';
 
 import { useQuery } from '@tanstack/react-query';
-import type { Optional } from '../../../_internal';
+import type { Optional } from '../../_internal';
 import {
 	type CountItemsOrdersForCollectionQueryOptions,
 	countItemsOrdersForCollectionQueryOptions,
 	type FetchCountItemsOrdersForCollectionParams,
-} from '../../../queries/orders/countItemsOrdersForCollection';
-import { useConfig } from '../../config/useConfig';
+} from '../../queries/collection/market-items-count';
+import { useConfig } from '../config/useConfig';
 
-export type UseCountItemsOrdersForCollectionParams = Optional<
+export type UseCollectionMarketItemsCountParams = Optional<
 	CountItemsOrdersForCollectionQueryOptions,
 	'config'
 >;
@@ -31,7 +31,7 @@ export type UseCountItemsOrdersForCollectionParams = Optional<
  * @example
  * Basic usage:
  * ```typescript
- * const { data: orderCount, isLoading } = useCountItemsOrdersForCollection({
+ * const { data: orderCount, isLoading } = useCollectionMarketItemsCount({
  *   chainId: 137,
  *   collectionAddress: '0x...'
  * })
@@ -40,7 +40,7 @@ export type UseCountItemsOrdersForCollectionParams = Optional<
  * @example
  * With filter:
  * ```typescript
- * const { data: filteredCount } = useCountItemsOrdersForCollection({
+ * const { data: filteredCount } = useCollectionMarketItemsCount({
  *   chainId: 137,
  *   collectionAddress: '0x...',
  *   filter: {
@@ -52,7 +52,7 @@ export type UseCountItemsOrdersForCollectionParams = Optional<
  * @example
  * Combined with list hook:
  * ```typescript
- * const { data: totalCount } = useCountItemsOrdersForCollection({
+ * const { data: totalCount } = useCollectionMarketItemsCount({
  *   chainId: 137,
  *   collectionAddress: '0x...'
  * })
@@ -65,8 +65,8 @@ export type UseCountItemsOrdersForCollectionParams = Optional<
  * return <div>Showing {orders?.pages[0]?.listings.length ?? 0} of {totalCount} orders</div>
  * ```
  */
-export function useCountItemsOrdersForCollection(
-	params: UseCountItemsOrdersForCollectionParams,
+export function useCollectionMarketItemsCount(
+	params: UseCollectionMarketItemsCountParams,
 ) {
 	const defaultConfig = useConfig();
 

package/src/react/hooks/collection/market-items-paginated.test.tsx

@@ -0,0 +1,142 @@
+import { OrderSide } from '@0xsequence/api-client';
+import * as MarketplaceMocks from '@0xsequence/api-client/mocks/marketplace';
+import { renderHook, server, waitFor } from '@test';
+import { HttpResponse, http } from 'msw';
+import { zeroAddress } from 'viem';
+import { describe, expect, it } from 'vitest';
+import type { UseCollectionMarketItemsPaginatedParams } from './market-items-paginated';
+import { useCollectionMarketItemsPaginated } from './market-items-paginated';
+
+const { mockMarketplaceEndpoint } = MarketplaceMocks;
+
+describe('useCollectionMarketItemsPaginated', () => {
+	const defaultArgs: UseCollectionMarketItemsPaginatedParams = {
+		chainId: 1,
+		collectionAddress: zeroAddress,
+		side: OrderSide.listing,
+		page: 1,
+		pageSize: 10,
+	};
+
+	it('should fetch paginated orders successfully', async () => {
+		const mockResponse = {
+			orders: [],
+			collectibles: [],
+			page: {
+				page: 1,
+				pageSize: 10,
+				more: false,
+			},
+		};
+
+		server.use(
+			http.post(mockMarketplaceEndpoint('ListOrdersWithCollectibles'), () => {
+				return HttpResponse.json(mockResponse);
+			}),
+		);
+
+		const { result } = renderHook(() =>
+			useCollectionMarketItemsPaginated(defaultArgs),
+		);
+
+		// Initially loading
+		expect(result.current.isLoading).toBe(true);
+		expect(result.current.data).toBeUndefined();
+
+		// Wait for data to be loaded
+		await waitFor(() => {
+			expect(result.current.isLoading).toBe(false);
+		});
+
+		// Verify the data matches our mock
+		expect(result.current.data).toEqual(mockResponse);
+		expect(result.current.error).toBeNull();
+	});
+
+	it('should handle error states', async () => {
+		server.use(
+			http.post(mockMarketplaceEndpoint('ListOrdersWithCollectibles'), () => {
+				return HttpResponse.json(
+					{ error: { message: 'Failed to fetch orders' } },
+					{ status: 500 },
+				);
+			}),
+		);
+
+		const { result } = renderHook(() =>
+			useCollectionMarketItemsPaginated(defaultArgs),
+		);
+
+		await waitFor(() => {
+			expect(result.current.isError).toBe(true);
+		});
+
+		expect(result.current.error).toBeDefined();
+		expect(result.current.data).toBeUndefined();
+	});
+
+	it('should refetch when page changes', async () => {
+		const mockResponsePage1 = {
+			orders: [],
+			collectibles: [],
+			page: { page: 1, pageSize: 10, more: true },
+		};
+		const mockResponsePage2 = {
+			orders: [],
+			collectibles: [],
+			page: { page: 2, pageSize: 10, more: false },
+		};
+
+		let requestedPage = 0;
+
+		server.use(
+			http.post(
+				mockMarketplaceEndpoint('ListOrdersWithCollectibles'),
+				async ({ request }) => {
+					const body = (await request.json()) as any;
+					requestedPage = body.page.page;
+					return HttpResponse.json(
+						requestedPage === 1 ? mockResponsePage1 : mockResponsePage2,
+					);
+				},
+			),
+		);
+
+		const { result, rerender } = renderHook(
+			(args: UseCollectionMarketItemsPaginatedParams = defaultArgs) =>
+				useCollectionMarketItemsPaginated(args),
+		);
+
+		// Wait for initial data (page 1)
+		await waitFor(() => {
+			expect(result.current.data).toEqual(mockResponsePage1);
+		});
+		expect(requestedPage).toBe(1);
+
+		// Change page and rerender
+		const newArgs = {
+			...defaultArgs,
+			page: 2,
+		};
+
+		rerender(newArgs);
+
+		// Wait for new data (page 2)
+		await waitFor(() => {
+			expect(result.current.data).toEqual(mockResponsePage2);
+		});
+		expect(requestedPage).toBe(2);
+	});
+
+	it('should not fetch if required params are missing', async () => {
+		const { result } = renderHook(() =>
+			useCollectionMarketItemsPaginated({
+				...defaultArgs,
+				chainId: undefined,
+			} as any),
+		);
+
+		expect(result.current.isLoading).toBe(false);
+		expect(result.current.data).toBeUndefined();
+	});
+});

package/src/react/hooks/{data/orders/useListItemsOrdersForCollectionPaginated.tsx → collection/market-items-paginated.tsx}

@@ -1,16 +1,16 @@
 'use client';
 
 import { useQuery } from '@tanstack/react-query';
-import type { Optional } from '../../../_internal';
+import type { Optional } from '../../_internal';
 import {
 	type FetchListItemsOrdersForCollectionPaginatedParams,
 	type fetchListItemsOrdersForCollectionPaginated,
 	type ListItemsOrdersForCollectionPaginatedQueryOptions,
 	listItemsOrdersForCollectionPaginatedQueryOptions,
-} from '../../../queries/orders/listItemsOrdersForCollectionPaginated';
-import { useConfig } from '../../config/useConfig';
+} from '../../queries/collection/market-items-paginated';
+import { useConfig } from '../config/useConfig';
 
-export type UseListItemsOrdersForCollectionPaginatedParams = Optional<
+export type UseCollectionMarketItemsPaginatedParams = Optional<
 	ListItemsOrdersForCollectionPaginatedQueryOptions,
 	'config'
 >;
@@ -36,7 +36,7 @@ export type UseListItemsOrdersForCollectionPaginatedParams = Optional<
  * @example
  * Basic usage:
  * ```typescript
- * const { data, isLoading } = useListItemsOrdersForCollectionPaginated({
+ * const { data, isLoading } = useCollectionMarketItemsPaginated({
  *   chainId: 137,
  *   collectionAddress: '0x...',
  *   side: OrderSide.listing,
@@ -48,7 +48,7 @@ export type UseListItemsOrdersForCollectionPaginatedParams = Optional<
  * @example
  * With filtering:
  * ```typescript
- * const { data } = useListItemsOrdersForCollectionPaginated({
+ * const { data } = useCollectionMarketItemsPaginated({
  *   chainId: 1,
  *   collectionAddress: '0x...',
  *   side: OrderSide.listing,
@@ -65,7 +65,7 @@ export type UseListItemsOrdersForCollectionPaginatedParams = Optional<
  * Controlled pagination:
  * ```typescript
  * const [currentPage, setCurrentPage] = useState(1);
- * const { data, isLoading } = useListItemsOrdersForCollectionPaginated({
+ * const { data, isLoading } = useCollectionMarketItemsPaginated({
  *   chainId: 137,
  *   collectionAddress: '0x...',
  *   side: OrderSide.listing,
@@ -76,8 +76,8 @@ export type UseListItemsOrdersForCollectionPaginatedParams = Optional<
  * const hasMorePages = data?.page?.more;
  * ```
  */
-export function useListItemsOrdersForCollectionPaginated(
-	params: UseListItemsOrdersForCollectionPaginatedParams,
+export function useCollectionMarketItemsPaginated(
+	params: UseCollectionMarketItemsPaginatedParams,
 ) {
 	const defaultConfig = useConfig();
 
@@ -106,3 +106,5 @@ export type UseListItemsOrdersForCollectionPaginatedArgs =
 export type UseListItemsOrdersForCollectionPaginatedReturn = Awaited<
 	ReturnType<typeof fetchListItemsOrdersForCollectionPaginated>
 >;
+export type UseListItemsOrdersForCollectionPaginatedParams =
+	UseCollectionMarketItemsPaginatedParams;