@0xsequence/marketplace-sdk 0.5.2 → 0.5.4

package/src/react/hooks/__tests__/useListCollections.test.tsx

@@ -0,0 +1,296 @@
+import { describe, expect, it, beforeEach } from 'vitest';
+import { useListCollections } from '../useListCollections';
+import { renderHook, waitFor } from '../../_internal/test-utils';
+import { http, HttpResponse } from 'msw';
+import { mockContractInfo } from '../../_internal/api/__mocks__/metadata.msw';
+import { server } from '../../_internal/test/setup';
+import { ResourceStatus } from '@0xsequence/metadata';
+import {
+	createConfigHandler,
+	createStylesHandler,
+	mockConfig,
+} from '../options/__mocks__/marketplaceConfig.msw';
+import { MarketplaceType, OrderbookKind } from '../../../types';
+
+describe('useListCollections', () => {
+	const defaultArgs = {
+		query: {
+			enabled: true,
+		},
+	};
+
+	// Reset handlers before each test
+	beforeEach(() => {
+		server.resetHandlers();
+		// Set up default handlers for config and styles
+		server.use(createConfigHandler(), createStylesHandler());
+	});
+
+	it('should fetch collections successfully', async () => {
+		// Mock marketplace config with collection
+		server.use(
+			createConfigHandler({
+				...mockConfig,
+				collections: [
+					{
+						chainId: 1,
+						address:
+							'0x1234567890123456789012345678901234567890' as `0x${string}`,
+						feePercentage: 2.5,
+						marketplaceType: MarketplaceType.ORDERBOOK,
+						currencyOptions: [],
+						exchanges: [],
+						bannerUrl: '',
+						destinationMarketplace: OrderbookKind.sequence_marketplace_v2,
+					},
+				],
+			}),
+			http.post('*/rpc/Metadata/GetContractInfoBatch', () => {
+				return HttpResponse.json({
+					contractInfoMap: {
+						'0x1234567890123456789012345678901234567890': mockContractInfo,
+					},
+				});
+			}),
+		);
+
+		const { result } = renderHook(() => useListCollections(defaultArgs));
+
+		// Wait for data to be loaded
+		await waitFor(() => {
+			expect(result.current.data).toBeDefined();
+		});
+
+		// Verify the data matches our mock
+		expect(result.current.data).toEqual([mockContractInfo]);
+		expect(result.current.error).toBeNull();
+	});
+
+	it('should handle empty collections', async () => {
+		// Mock marketplace config with empty collections
+		server.use(
+			createConfigHandler({
+				...mockConfig,
+				collections: [],
+			}),
+		);
+
+		const { result } = renderHook(() => useListCollections(defaultArgs));
+
+		await waitFor(() => {
+			expect(result.current.data).toBeDefined();
+		});
+
+		expect(result.current.data).toEqual([]);
+		expect(result.current.error).toBeNull();
+	});
+
+	it('should handle error states', async () => {
+		// Mock marketplace config with collection
+		server.use(
+			createConfigHandler({
+				...mockConfig,
+				collections: [
+					{
+						chainId: 1,
+						address:
+							'0x1234567890123456789012345678901234567890' as `0x${string}`,
+						feePercentage: 2.5,
+						marketplaceType: MarketplaceType.ORDERBOOK,
+						currencyOptions: [],
+						exchanges: [],
+						bannerUrl: '',
+						destinationMarketplace: OrderbookKind.sequence_marketplace_v2,
+					},
+				],
+			}),
+			http.post('*/rpc/Metadata/GetContractInfoBatch', () => {
+				return new HttpResponse(
+					JSON.stringify({ error: { message: 'Failed to fetch collections' } }),
+					{ status: 500 },
+				);
+			}),
+		);
+
+		const { result } = renderHook(() => useListCollections(defaultArgs));
+
+		await waitFor(() => {
+			expect(result.current.isError).toBe(true);
+		});
+
+		expect(result.current.error).toBeDefined();
+		expect(result.current.data).toBeUndefined();
+	});
+
+	it('should handle disabled queries', async () => {
+		let requestMade = false;
+
+		// Mock marketplace config with collection
+		server.use(
+			createConfigHandler({
+				...mockConfig,
+				collections: [
+					{
+						chainId: 1,
+						address:
+							'0x1234567890123456789012345678901234567890' as `0x${string}`,
+						feePercentage: 2.5,
+						marketplaceType: MarketplaceType.ORDERBOOK,
+						currencyOptions: [],
+						exchanges: [],
+						bannerUrl: '',
+						destinationMarketplace: OrderbookKind.sequence_marketplace_v2,
+					},
+				],
+			}),
+			http.post('*/rpc/Metadata/GetContractInfoBatch', () => {
+				requestMade = true;
+				return HttpResponse.json({
+					contractInfoMap: {
+						'0x1234567890123456789012345678901234567890': mockContractInfo,
+					},
+				});
+			}),
+		);
+
+		const disabledArgs = {
+			query: {
+				enabled: false,
+			},
+		};
+
+		const { result } = renderHook(() => useListCollections(disabledArgs));
+
+		// For disabled queries, we expect no loading state and no data
+		expect(result.current.isLoading).toBe(false);
+		expect(result.current.data).toBeUndefined();
+		expect(result.current.error).toBeNull();
+		expect(requestMade).toBe(false);
+	});
+
+	it('should handle multiple collections from different chains', async () => {
+		const mockContractInfo2 = {
+			...mockContractInfo,
+			address: '0x1234567890123456789012345678901234567890' as `0x${string}`,
+			chainId: 137, // Different chain (Polygon)
+		};
+
+		// Mock marketplace config with multiple collections
+		server.use(
+			createConfigHandler({
+				...mockConfig,
+				collections: [
+					{
+						chainId: 1,
+						address:
+							'0x1234567890123456789012345678901234567890' as `0x${string}`,
+						feePercentage: 2.5,
+						marketplaceType: MarketplaceType.ORDERBOOK,
+						currencyOptions: [],
+						exchanges: [],
+						bannerUrl: '',
+						destinationMarketplace: OrderbookKind.sequence_marketplace_v2,
+					},
+					{
+						chainId: 137,
+						address: mockContractInfo2.address,
+						feePercentage: 2.5,
+						marketplaceType: MarketplaceType.ORDERBOOK,
+						currencyOptions: [],
+						exchanges: [],
+						bannerUrl: '',
+						destinationMarketplace: OrderbookKind.sequence_marketplace_v2,
+					},
+				],
+			}),
+			http.post('*/rpc/Metadata/GetContractInfoBatch', async ({ request }) => {
+				const body = (await request.json()) as { chainID: string };
+				if (body.chainID === '1') {
+					return HttpResponse.json({
+						contractInfoMap: {
+							'0x1234567890123456789012345678901234567890': mockContractInfo,
+						},
+					});
+				}
+				return HttpResponse.json({
+					contractInfoMap: {
+						[mockContractInfo2.address]: mockContractInfo2,
+					},
+				});
+			}),
+		);
+
+		const { result } = renderHook(() => useListCollections(defaultArgs));
+
+		await waitFor(() => {
+			expect(result.current.data).toBeDefined();
+		});
+
+		expect(result.current.data).toHaveLength(2);
+		expect(result.current.data).toEqual(
+			expect.arrayContaining([mockContractInfo, mockContractInfo2]),
+		);
+	});
+
+	it('should handle collections with different resource statuses', async () => {
+		const mockUnavailableContract = {
+			...mockContractInfo,
+			address: '0x9876543210987654321098765432109876543210' as `0x${string}`,
+			status: ResourceStatus.NOT_AVAILABLE,
+		};
+
+		// Mock marketplace config with multiple collections
+		server.use(
+			createConfigHandler({
+				...mockConfig,
+				collections: [
+					{
+						chainId: 1,
+						address:
+							'0x1234567890123456789012345678901234567890' as `0x${string}`,
+						feePercentage: 2.5,
+						marketplaceType: MarketplaceType.ORDERBOOK,
+						currencyOptions: [],
+						exchanges: [],
+						bannerUrl: '',
+						destinationMarketplace: OrderbookKind.sequence_marketplace_v2,
+					},
+					{
+						chainId: 1,
+						address: mockUnavailableContract.address,
+						feePercentage: 2.5,
+						marketplaceType: MarketplaceType.ORDERBOOK,
+						currencyOptions: [],
+						exchanges: [],
+						bannerUrl: '',
+						destinationMarketplace: OrderbookKind.sequence_marketplace_v2,
+					},
+				],
+			}),
+		);
+
+		// Mock metadata response for both contracts
+		server.use(
+			http.post('*/rpc/Metadata/GetContractInfoBatch', () => {
+				return HttpResponse.json({
+					contractInfoMap: {
+						'0x1234567890123456789012345678901234567890': mockContractInfo,
+						'0x9876543210987654321098765432109876543210':
+							mockUnavailableContract,
+					},
+				});
+			}),
+		);
+
+		const { result } = renderHook(() => useListCollections(defaultArgs));
+
+		await waitFor(() => {
+			expect(result.current.data).toBeDefined();
+		});
+
+		expect(result.current.data).toHaveLength(2);
+		expect(result.current.data).toEqual(
+			expect.arrayContaining([mockContractInfo, mockUnavailableContract]),
+		);
+	});
+});

package/src/react/hooks/__tests__/useListListingsForCollectible.test.tsx

@@ -0,0 +1,140 @@
+import { describe, expect, it } from 'vitest';
+import { useListListingsForCollectible } from '../useListListingsForCollectible';
+import { renderHook, waitFor } from '../../_internal/test-utils';
+import { zeroAddress } from 'viem';
+import { MarketplaceKind } from '../../_internal/api/marketplace.gen';
+import { http, HttpResponse } from 'msw';
+import {
+	mockOrder,
+	mockMarketplaceEndpoint,
+} from '../../_internal/api/__mocks__/marketplace.msw';
+import { server } from '../../_internal/test/setup';
+
+describe('useListListingsForCollectible', () => {
+	const defaultArgs = {
+		chainId: '1',
+		collectionAddress: zeroAddress,
+		collectibleId: '1',
+		page: {
+			page: 1,
+			pageSize: 10,
+		},
+	} as const;
+
+	it('should fetch listings data successfully', async () => {
+		const { result } = renderHook(() =>
+			useListListingsForCollectible(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).toBeDefined();
+		expect(result.current.data?.listings).toEqual([mockOrder]);
+		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('ListCollectibleListings'), () => {
+				return HttpResponse.json(
+					{ error: { message: 'Failed to fetch listings' } },
+					{ status: 500 },
+				);
+			}),
+		);
+
+		const { result } = renderHook(() =>
+			useListListingsForCollectible(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 { result, rerender } = renderHook(() =>
+			useListListingsForCollectible(defaultArgs),
+		);
+
+		// Wait for initial data
+		await waitFor(() => {
+			expect(result.current.isLoading).toBe(false);
+		});
+
+		// Change args and rerender
+		const newArgs = {
+			...defaultArgs,
+			collectibleId: '2',
+		};
+
+		rerender(() => useListListingsForCollectible(newArgs));
+
+		// Wait for new data
+		await waitFor(() => {
+			expect(result.current.data).toBeDefined();
+		});
+
+		// Verify that the query was refetched with new args
+		expect(result.current.data?.listings).toEqual([mockOrder]);
+		expect(result.current.isSuccess).toBe(true);
+	});
+
+	it('should handle pagination correctly', async () => {
+		const paginatedArgs = {
+			...defaultArgs,
+			page: {
+				page: 2,
+				pageSize: 20,
+			},
+		} as const;
+
+		const { result } = renderHook(() =>
+			useListListingsForCollectible(paginatedArgs),
+		);
+
+		await waitFor(() => {
+			expect(result.current.isLoading).toBe(false);
+		});
+
+		expect(result.current.data?.page).toBeDefined();
+		expect(result.current.data?.page?.page).toBe(1);
+		expect(result.current.data?.page?.pageSize).toBe(10);
+		expect(result.current.data?.page?.more).toBe(false);
+	});
+
+	it('should handle optional filter parameter', async () => {
+		const argsWithFilter = {
+			...defaultArgs,
+			filter: {
+				marketplace: [
+					MarketplaceKind.sequence_marketplace_v2,
+				] as MarketplaceKind[],
+				currencies: [zeroAddress] as string[],
+			},
+		} as const;
+
+		const { result } = renderHook(() =>
+			useListListingsForCollectible(argsWithFilter),
+		);
+
+		await waitFor(() => {
+			expect(result.current.isLoading).toBe(false);
+		});
+
+		expect(result.current.data?.listings).toEqual([mockOrder]);
+		expect(result.current.isSuccess).toBe(true);
+	});
+});

package/src/react/hooks/__tests__/useListOffersForCollectible.test.tsx

@@ -0,0 +1,140 @@
+import { describe, expect, it } from 'vitest';
+import { useListOffersForCollectible } from '../useListOffersForCollectible';
+import { renderHook, waitFor } from '../../_internal/test-utils';
+import { zeroAddress } from 'viem';
+import { MarketplaceKind } from '../../_internal/api/marketplace.gen';
+import { http, HttpResponse } from 'msw';
+import {
+	mockOrder,
+	mockMarketplaceEndpoint,
+} from '../../_internal/api/__mocks__/marketplace.msw';
+import { server } from '../../_internal/test/setup';
+
+describe('useListOffersForCollectible', () => {
+	const defaultArgs = {
+		chainId: '1',
+		collectionAddress: zeroAddress,
+		collectibleId: '1',
+		page: {
+			page: 1,
+			pageSize: 10,
+		},
+	};
+
+	it('should fetch offers data successfully', async () => {
+		const { result } = renderHook(() =>
+			useListOffersForCollectible(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).toBeDefined();
+		expect(result.current.data?.offers).toEqual([mockOrder]);
+		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('ListCollectibleOffers'), () => {
+				return HttpResponse.json(
+					{ error: { message: 'Failed to fetch offers' } },
+					{ status: 500 },
+				);
+			}),
+		);
+
+		const { result } = renderHook(() =>
+			useListOffersForCollectible(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 { result, rerender } = renderHook(() =>
+			useListOffersForCollectible(defaultArgs),
+		);
+
+		// Wait for initial data
+		await waitFor(() => {
+			expect(result.current.isLoading).toBe(false);
+		});
+
+		// Change args and rerender
+		const newArgs = {
+			...defaultArgs,
+			collectibleId: '2',
+		};
+
+		rerender(() => useListOffersForCollectible(newArgs));
+
+		// Wait for new data
+		await waitFor(() => {
+			expect(result.current.data).toBeDefined();
+		});
+
+		// Verify that the query was refetched with new args
+		expect(result.current.data?.offers).toEqual([mockOrder]);
+		expect(result.current.isSuccess).toBe(true);
+	});
+
+	it('should handle pagination correctly', async () => {
+		const paginatedArgs = {
+			...defaultArgs,
+			page: {
+				page: 2,
+				pageSize: 20,
+			},
+		};
+
+		const { result } = renderHook(() =>
+			useListOffersForCollectible(paginatedArgs),
+		);
+
+		await waitFor(() => {
+			expect(result.current.isLoading).toBe(false);
+		});
+
+		expect(result.current.data?.page).toBeDefined();
+		expect(result.current.data?.page?.page).toBe(1);
+		expect(result.current.data?.page?.pageSize).toBe(10);
+		expect(result.current.data?.page?.more).toBe(false);
+	});
+
+	it('should handle optional filter parameter', async () => {
+		const argsWithFilter = {
+			...defaultArgs,
+			filter: {
+				marketplace: [
+					MarketplaceKind.sequence_marketplace_v2,
+				] as MarketplaceKind[],
+				currencies: [zeroAddress] as string[],
+			},
+		};
+
+		const { result } = renderHook(() =>
+			useListOffersForCollectible(argsWithFilter),
+		);
+
+		await waitFor(() => {
+			expect(result.current.isLoading).toBe(false);
+		});
+
+		expect(result.current.data?.offers).toEqual([mockOrder]);
+		expect(result.current.isSuccess).toBe(true);
+	});
+});