@0xsequence/marketplace-sdk 0.8.12 → 0.10.0

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

@@ -0,0 +1,301 @@
+import { renderHook, server, waitFor } from '@test';
+import { HttpResponse, http } from 'msw';
+import { zeroAddress } from 'viem';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { useDisconnect } from 'wagmi';
+import {
+	CollectibleCardAction,
+	ContractType,
+	OrderbookKind,
+} from '../../../types';
+import {
+	mockIndexerEndpoint,
+	mockTokenBalance,
+} from '../../_internal/api/__mocks__/indexer.msw';
+import {
+	mockCollectibleOrder,
+	mockMarketplaceEndpoint,
+} from '../../_internal/api/__mocks__/marketplace.msw';
+import { PropertyType } from '../../_internal/api/marketplace.gen';
+import { useListMarketCardData } from '../useListMarketCardData';
+
+describe('useListMarketCardData', () => {
+	const defaultProps = {
+		collectionAddress: zeroAddress,
+		chainId: 1,
+		orderbookKind: OrderbookKind.sequence_marketplace_v2,
+		collectionType: ContractType.ERC721,
+	};
+
+	beforeEach(() => {
+		// Set up default handlers for successful API responses
+		server.use(
+			http.post(mockMarketplaceEndpoint('ListCollectibles'), () => {
+				return HttpResponse.json({
+					page: { page: 1, pageSize: 10, more: false },
+					collectibles: [mockCollectibleOrder],
+				});
+			}),
+			http.post(mockIndexerEndpoint('GetTokenBalancesDetails'), () => {
+				return HttpResponse.json({
+					page: { page: 1, pageSize: 10, more: false },
+					balances: [
+						{
+							...mockTokenBalance,
+							balance: '1',
+							contractAddress: zeroAddress,
+						},
+					],
+					nativeBalances: [],
+				});
+			}),
+		);
+	});
+
+	afterEach(() => {
+		vi.clearAllMocks();
+	});
+
+	it('should fetch collectibles and balances when wallet is connected', async () => {
+		const { result } = renderHook(() => useListMarketCardData(defaultProps));
+
+		await waitFor(() => {
+			expect(result.current.isLoading).toBe(false);
+		});
+
+		expect(result.current.collectibleCards).toHaveLength(1);
+		expect(result.current.error).toBeNull();
+	});
+
+	it('should handle disconnected wallet state', async () => {
+		const { result: disconnect } = renderHook(() => useDisconnect());
+		await disconnect.current.disconnectAsync();
+
+		const { result } = renderHook(() => useListMarketCardData(defaultProps));
+
+		await waitFor(() => {
+			expect(result.current.isLoading).toBe(false);
+		});
+
+		expect(result.current.collectibleCards).toHaveLength(1);
+		// Should still work without wallet, just won't show balance
+		expect(result.current.error).toBeNull();
+	});
+
+	it('should handle API errors gracefully', async () => {
+		server.use(
+			http.post(mockMarketplaceEndpoint('ListCollectibles'), () => {
+				return new HttpResponse(null, {
+					status: 500,
+					statusText: 'Internal Server Error',
+				});
+			}),
+		);
+
+		const { result } = renderHook(() => useListMarketCardData(defaultProps));
+
+		await waitFor(() => {
+			expect(result.current.isLoading).toBe(false);
+		});
+
+		expect(result.current.error).toBeTruthy();
+		expect(result.current.collectibleCards).toHaveLength(0);
+	});
+
+	it('should handle search text filtering', async () => {
+		const { result } = renderHook(() =>
+			useListMarketCardData({
+				...defaultProps,
+				searchText: 'test search',
+			}),
+		);
+
+		await waitFor(() => {
+			expect(result.current.isLoading).toBe(false);
+		});
+
+		expect(result.current.collectibleCards).toHaveLength(1);
+	});
+
+	it('should handle property filtering', async () => {
+		const { result } = renderHook(() =>
+			useListMarketCardData({
+				...defaultProps,
+				filterOptions: [
+					{
+						name: 'Background',
+						type: PropertyType.STRING,
+						values: ['Blue'],
+					},
+				],
+			}),
+		);
+
+		await waitFor(() => {
+			expect(result.current.isLoading).toBe(false);
+		});
+
+		expect(result.current.collectibleCards).toHaveLength(1);
+	});
+
+	it('should handle listed-only filtering', async () => {
+		const { result } = renderHook(() =>
+			useListMarketCardData({
+				...defaultProps,
+				showListedOnly: true,
+			}),
+		);
+
+		await waitFor(() => {
+			expect(result.current.isLoading).toBe(false);
+		});
+
+		expect(result.current.collectibleCards).toHaveLength(1);
+	});
+
+	it('should handle collectible click callback', async () => {
+		const onCollectibleClick = vi.fn();
+
+		const { result } = renderHook(() =>
+			useListMarketCardData({
+				...defaultProps,
+				onCollectibleClick,
+			}),
+		);
+
+		await waitFor(() => {
+			expect(result.current.isLoading).toBe(false);
+		});
+
+		// Simulate clicking the collectible
+		result.current.collectibleCards[0].onCollectibleClick?.('1');
+		expect(onCollectibleClick).toHaveBeenCalledWith('1');
+	});
+
+	it('should handle cannot perform action callback', async () => {
+		const onCannotPerformAction = vi.fn();
+
+		const { result } = renderHook(() =>
+			useListMarketCardData({
+				...defaultProps,
+				onCannotPerformAction,
+			}),
+		);
+
+		await waitFor(() => {
+			expect(result.current.isLoading).toBe(false);
+		});
+
+		// Simulate action that cannot be performed
+		result.current.collectibleCards[0].onCannotPerformAction?.(
+			CollectibleCardAction.BUY,
+		);
+		expect(onCannotPerformAction).toHaveBeenCalledWith(
+			CollectibleCardAction.BUY,
+		);
+	});
+
+	it('should prioritize owner actions when specified', async () => {
+		const { result } = renderHook(() =>
+			useListMarketCardData({
+				...defaultProps,
+				prioritizeOwnerActions: true,
+			}),
+		);
+
+		await waitFor(() => {
+			expect(result.current.isLoading).toBe(false);
+		});
+
+		expect(result.current.collectibleCards[0].prioritizeOwnerActions).toBe(
+			true,
+		);
+	});
+
+	it('should use custom asset source prefix URL when provided', async () => {
+		const assetSrcPrefixUrl = 'https://custom-cdn.example.com/';
+
+		const { result } = renderHook(() =>
+			useListMarketCardData({
+				...defaultProps,
+				assetSrcPrefixUrl,
+			}),
+		);
+
+		await waitFor(() => {
+			expect(result.current.isLoading).toBe(false);
+		});
+
+		expect(result.current.collectibleCards[0].assetSrcPrefixUrl).toBe(
+			assetSrcPrefixUrl,
+		);
+	});
+
+	it('should handle pagination correctly', async () => {
+		// Mock first page
+		server.use(
+			http.post(mockMarketplaceEndpoint('ListCollectibles'), () => {
+				return HttpResponse.json({
+					page: { page: 1, pageSize: 10, more: true },
+					collectibles: [mockCollectibleOrder],
+				});
+			}),
+		);
+
+		const { result } = renderHook(() => useListMarketCardData(defaultProps));
+
+		await waitFor(() => {
+			expect(result.current.isLoading).toBe(false);
+		});
+
+		expect(result.current.hasNextPage).toBe(true);
+		expect(result.current.isFetchingNextPage).toBe(false);
+
+		// Mock second page
+		server.use(
+			http.post(mockMarketplaceEndpoint('ListCollectibles'), () => {
+				return HttpResponse.json({
+					page: { page: 2, pageSize: 10, more: false },
+					collectibles: [
+						{
+							...mockCollectibleOrder,
+							metadata: { ...mockCollectibleOrder.metadata, tokenId: '2' },
+						},
+					],
+				});
+			}),
+		);
+
+		// Fetch next page
+		await result.current.fetchNextPage();
+
+		await waitFor(() => {
+			expect(result.current.isFetchingNextPage).toBe(false);
+		});
+
+		expect(result.current.allCollectibles).toHaveLength(2);
+		expect(result.current.hasNextPage).toBe(false);
+	});
+
+	it('should handle combined filters (search text and properties)', async () => {
+		const { result } = renderHook(() =>
+			useListMarketCardData({
+				...defaultProps,
+				searchText: 'test search',
+				filterOptions: [
+					{
+						name: 'Background',
+						type: PropertyType.STRING,
+						values: ['Blue'],
+					},
+				],
+			}),
+		);
+
+		await waitFor(() => {
+			expect(result.current.isLoading).toBe(false);
+		});
+
+		expect(result.current.collectibleCards).toHaveLength(1);
+	});
+});

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

@@ -1,5 +1,5 @@
 import { renderHook, server, waitFor } from '@test';
-import { http, HttpResponse } from 'msw';
+import { HttpResponse, http } from 'msw';
 import { zeroAddress } from 'viem';
 import { describe, expect, it } from 'vitest';
 import {

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

@@ -0,0 +1,137 @@
+import { renderHook, server, waitFor } from '@test';
+import { HttpResponse, http } from 'msw';
+import { describe, expect, it } from 'vitest';
+import {
+	mockEthCollection,
+	mockMetadataEndpoint,
+	mockTokenMetadata,
+} from '../../_internal/api/__mocks__/metadata.msw';
+import type { UseListTokenMetadataParams } from '../useListTokenMetadata';
+import { useListTokenMetadata } from '../useListTokenMetadata';
+
+describe('useListTokenMetadata', () => {
+	const defaultArgs: UseListTokenMetadataParams = {
+		chainId: mockEthCollection.chainId,
+		contractAddress: mockEthCollection.address,
+		tokenIds: ['1', '2', '3'],
+	};
+
+	it('should fetch token metadata successfully', async () => {
+		const { result } = renderHook(() => useListTokenMetadata(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([mockTokenMetadata]);
+		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(mockMetadataEndpoint('GetTokenMetadata'), () => {
+				return HttpResponse.json(
+					{ error: { message: 'Failed to fetch token metadata' } },
+					{ status: 500 },
+				);
+			}),
+		);
+
+		const { result } = renderHook(() => useListTokenMetadata(defaultArgs));
+
+		// Wait for error to be set
+		await waitFor(() => {
+			expect(result.current.isError).toBe(true);
+		});
+
+		expect(result.current.data).toBeUndefined();
+		expect(result.current.error).toBeTruthy();
+	});
+
+	it('should handle disabled queries', () => {
+		const disabledParams = {
+			...defaultArgs,
+			query: {
+				enabled: false,
+			},
+		};
+
+		const { result } = renderHook(() => useListTokenMetadata(disabledParams));
+
+		// 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();
+	});
+
+	it('should handle empty token IDs array', () => {
+		const emptyTokensParams = {
+			...defaultArgs,
+			tokenIds: [],
+		};
+
+		const { result } = renderHook(() =>
+			useListTokenMetadata(emptyTokensParams),
+		);
+
+		// Empty token IDs should disable the query
+		expect(result.current.isLoading).toBe(false);
+		expect(result.current.data).toBeUndefined();
+		expect(result.current.error).toBeNull();
+	});
+
+	it('should handle missing required parameters', () => {
+		const invalidParams = {
+			chainId: defaultArgs.chainId,
+			contractAddress: '',
+			tokenIds: defaultArgs.tokenIds,
+		};
+
+		const { result } = renderHook(() => useListTokenMetadata(invalidParams));
+
+		// Missing contract address should disable the query
+		expect(result.current.isLoading).toBe(false);
+		expect(result.current.data).toBeUndefined();
+		expect(result.current.error).toBeNull();
+	});
+
+	it('should pass correct parameters to API', async () => {
+		let capturedRequest: unknown;
+
+		// Override the handler to capture the request
+		server.use(
+			http.post(mockMetadataEndpoint('GetTokenMetadata'), async (request) => {
+				capturedRequest = await request.request.json();
+				return HttpResponse.json({
+					tokenMetadata: [mockTokenMetadata],
+				});
+			}),
+		);
+
+		const customParams = {
+			chainId: 137,
+			contractAddress: '0x1234567890123456789012345678901234567890',
+			tokenIds: ['10', '20', '30'],
+		};
+
+		const { result } = renderHook(() => useListTokenMetadata(customParams));
+
+		await waitFor(() => {
+			expect(result.current.isLoading).toBe(false);
+		});
+
+		// Verify the API was called with correct parameters
+		expect(capturedRequest).toEqual({
+			chainID: '137',
+			contractAddress: '0x1234567890123456789012345678901234567890',
+			tokenIDs: ['10', '20', '30'],
+		});
+	});
+});

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

@@ -1,5 +1,5 @@
 import { renderHook, server, waitFor } from '@test';
-import { http, HttpResponse } from 'msw';
+import { HttpResponse, http } from 'msw';
 import { zeroAddress } from 'viem';
 import { describe, expect, it } from 'vitest';
 import {

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

@@ -1,6 +1,6 @@
 import { renderHook, server, waitFor } from '@test';
 import { USDC_ADDRESS } from '@test/const';
-import { http, HttpResponse } from 'msw';
+import { HttpResponse, http } from 'msw';
 import type { Address } from 'viem';
 import { describe, expect, it } from 'vitest';
 import { mockConfig } from '../../_internal/api/__mocks__/builder.msw';

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

@@ -25,27 +25,4 @@ describe('useRoyaltyPercentage', () => {
 			}
 		`);
 	});
-
-	it('should handle invalid args', async () => {
-		const invalidArgs = {
-			collectionAddress: 'invalid-collection-address' as `0x${string}`,
-			chainId: 'invalid-chain-id',
-			collectibleId: '1',
-		};
-
-		// @ts-expect-error - This will fail Zod validation
-		const { result } = renderHook(() => useRoyalty(invalidArgs));
-
-		expect(result.current.isLoading).toBe(true);
-
-		await waitFor(
-			() => {
-				expect(result.current.isLoading).toBe(false);
-			},
-			{ timeout: 1000000 },
-		);
-
-		expect(result.current.data).toBeNull();
-		expect(result.current.error).toBeDefined();
-	});
 });