@0xsequence/marketplace-sdk 0.8.11 → 0.9.0

package/src/react/hooks/__tests__/useListCollectibles.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 type { ListCollectiblesArgs } from '../../_internal';
@@ -12,11 +12,11 @@ import {
 	OrderSide,
 } from '../../_internal/api/marketplace.gen';
 
-import type { UseListCollectiblesArgs } from '../../queries/listCollectibles';
+import type { UseListCollectiblesParams } from '../useListCollectibles';
 import { useListCollectibles } from '../useListCollectibles';
 
 describe('useListCollectibles', () => {
-	const defaultArgs: UseListCollectiblesArgs = {
+	const defaultArgs: UseListCollectiblesParams = {
 		chainId: 1,
 		collectionAddress: zeroAddress,
 		side: OrderSide.listing,
@@ -136,7 +136,7 @@ describe('useListCollectibles', () => {
 			}),
 		);
 
-		const disabledArgs: UseListCollectiblesArgs = {
+		const disabledArgs: UseListCollectiblesParams = {
 			...defaultArgs,
 			query: {
 				enabled: false,
@@ -193,7 +193,7 @@ describe('useListCollectibles', () => {
 	});
 
 	it('should handle filter parameters', async () => {
-		const argsWithFilter: UseListCollectiblesArgs = {
+		const argsWithFilter: UseListCollectiblesParams = {
 			...defaultArgs,
 			filter: {
 				includeEmpty: true,

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

@@ -1,6 +1,6 @@
 import { renderHook, server } from '@test';
 import { waitFor } from '@testing-library/react';
-import { http, HttpResponse } from 'msw';
+import { HttpResponse, http } from 'msw';
 import { zeroAddress } from 'viem';
 import { describe, expect, it } from 'vitest';
 import {
@@ -8,18 +8,18 @@ import {
 	mockMarketplaceEndpoint,
 } from '../../_internal/api/__mocks__/marketplace.msw';
 import { OrderSide } from '../../_internal/api/marketplace.gen';
-import type { UseListCollectiblesPaginatedArgs } from '../useListCollectiblesPaginated';
+import type { UseListCollectiblesPaginatedParams } from '../useListCollectiblesPaginated';
 import { useListCollectiblesPaginated } from '../useListCollectiblesPaginated';
 
 describe('useListCollectiblesPaginated', () => {
-	const defaultArgs: UseListCollectiblesPaginatedArgs = {
+	const defaultArgs: UseListCollectiblesPaginatedParams = {
 		chainId: 1,
 		collectionAddress: zeroAddress,
 		side: OrderSide.listing,
+		page: 1,
+		pageSize: 30,
 		query: {
 			enabled: true,
-			page: 1,
-			pageSize: 30,
 		},
 	};
 
@@ -95,12 +95,12 @@ describe('useListCollectiblesPaginated', () => {
 			}),
 		);
 
-		const paginatedArgs: UseListCollectiblesPaginatedArgs = {
+		const paginatedArgs: UseListCollectiblesPaginatedParams = {
 			...defaultArgs,
+			page: 2,
+			pageSize: 20,
 			query: {
 				enabled: true,
-				page: 2,
-				pageSize: 20,
 			},
 		};
 
@@ -146,10 +146,7 @@ describe('useListCollectiblesPaginated', () => {
 		// Change args and rerender
 		currentArgs = {
 			...defaultArgs,
-			query: {
-				...defaultArgs.query,
-				page: 2,
-			},
+			page: 2,
 		};
 
 		// Set up mock response for page 2
@@ -194,12 +191,10 @@ describe('useListCollectiblesPaginated', () => {
 			}),
 		);
 
-		const disabledArgs: UseListCollectiblesPaginatedArgs = {
+		const disabledArgs: UseListCollectiblesPaginatedParams = {
 			...defaultArgs,
 			query: {
 				enabled: false,
-				page: 1,
-				pageSize: 30,
 			},
 		};
 

package/src/react/hooks/__tests__/useListCollectionActivities.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 {
@@ -8,17 +8,17 @@ import {
 } from '../../_internal/api/__mocks__/marketplace.msw';
 import type { ListCollectionActivitiesArgs } from '../../_internal/api/marketplace.gen';
 import { SortOrder } from '../../_internal/api/marketplace.gen';
-import type { UseListCollectionActivitiesArgs } from '../useListCollectionActivities';
+import type { UseListCollectionActivitiesParams } from '../useListCollectionActivities';
 import { useListCollectionActivities } from '../useListCollectionActivities';
 
 describe('useListCollectionActivities', () => {
-	const defaultArgs: UseListCollectionActivitiesArgs = {
+	const defaultArgs: UseListCollectionActivitiesParams = {
 		chainId: 1,
 		collectionAddress: zeroAddress,
+		page: 1,
+		pageSize: 10,
 		query: {
 			enabled: true,
-			page: 1,
-			pageSize: 10,
 		},
 	};
 
@@ -90,12 +90,10 @@ describe('useListCollectionActivities', () => {
 			}),
 		);
 
-		const disabledArgs: UseListCollectionActivitiesArgs = {
+		const disabledArgs: UseListCollectionActivitiesParams = {
 			...defaultArgs,
 			query: {
 				enabled: false,
-				page: 1,
-				pageSize: 10,
 			},
 		};
 
@@ -151,13 +149,13 @@ describe('useListCollectionActivities', () => {
 	});
 
 	it('should handle sorting parameters', async () => {
-		const argsWithSort: UseListCollectionActivitiesArgs = {
+		const argsWithSort: UseListCollectionActivitiesParams = {
 			...defaultArgs,
+			page: 1,
+			pageSize: 10,
+			sort: [{ column: 'createdAt', order: SortOrder.DESC }],
 			query: {
 				enabled: true,
-				page: 1,
-				pageSize: 10,
-				sort: [{ column: 'createdAt', order: SortOrder.DESC }],
 			},
 		};
 
@@ -203,12 +201,12 @@ describe('useListCollectionActivities', () => {
 			}),
 		);
 
-		const paginatedArgs: UseListCollectionActivitiesArgs = {
+		const paginatedArgs: UseListCollectionActivitiesParams = {
 			...defaultArgs,
+			page: 2,
+			pageSize: 20,
 			query: {
 				enabled: true,
-				page: 2,
-				pageSize: 20,
 			},
 		};
 

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

@@ -1,5 +1,5 @@
 import { renderHook, server, waitFor } from '@test';
-import { http, HttpResponse } from 'msw';
+import { HttpResponse, http } from 'msw';
 import type { Address } from 'viem';
 import { describe, expect, it } from 'vitest';
 import { OrderbookKind } from '../../_internal';
@@ -39,7 +39,7 @@ describe('useListCollections', () => {
 			expect(result.current.data).toBeDefined();
 		});
 
-		expect(result.current.data).toEqual([]);
+		expect(result.current.data).toMatchSnapshot();
 		expect(result.current.error).toBeNull();
 	});
 
@@ -81,13 +81,13 @@ describe('useListCollections', () => {
 			}),
 		);
 
-		const disabledArgs = {
+		const disabledParams = {
 			query: {
 				enabled: false,
 			},
 		};
 
-		const { result } = renderHook(() => useListCollections(disabledArgs));
+		const { result } = renderHook(() => useListCollections(disabledParams));
 
 		// For disabled queries, we expect no loading state and no data
 		expect(result.current.isLoading).toBe(false);

package/src/react/hooks/__tests__/useListListingsForCollectible.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 {
@@ -7,10 +7,11 @@ import {
 	mockOrder,
 } from '../../_internal/api/__mocks__/marketplace.msw';
 import { MarketplaceKind } from '../../_internal/api/marketplace.gen';
+import type { UseListListingsForCollectibleParams } from '../useListListingsForCollectible';
 import { useListListingsForCollectible } from '../useListListingsForCollectible';
 
 describe('useListListingsForCollectible', () => {
-	const defaultArgs = {
+	const defaultArgs: UseListListingsForCollectibleParams = {
 		chainId: 1,
 		collectionAddress: zeroAddress,
 		collectibleId: '1',

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,111 @@
+import { renderHook, server, waitFor } from '@test';
+import { HttpResponse, http } from 'msw';
+import { describe, expect, it } from 'vitest';
+import { useListTokenMetadata } from '../useListTokenMetadata';
+
+describe('useListTokenMetadata', () => {
+	const defaultParams = {
+		chainId: 1,
+		contractAddress: '0x1234567890123456789012345678901234567890',
+		tokenIds: ['1', '2', '3'],
+	};
+
+	const mockTokenMetadata = [
+		{
+			tokenId: '1',
+			contractAddress: '0x1234567890123456789012345678901234567890',
+			name: 'Token 1',
+			description: 'First token',
+			image: 'https://example.com/1.png',
+		},
+		{
+			tokenId: '2',
+			contractAddress: '0x1234567890123456789012345678901234567890',
+			name: 'Token 2',
+			description: 'Second token',
+			image: 'https://example.com/2.png',
+		},
+		{
+			tokenId: '3',
+			contractAddress: '0x1234567890123456789012345678901234567890',
+			name: 'Token 3',
+			description: 'Third token',
+			image: 'https://example.com/3.png',
+		},
+	];
+
+	it('should fetch token metadata successfully', async () => {
+		// Mock the metadata API response
+		server.use(
+			http.post('*/rpc/Metadata/GetTokenMetadata', () => {
+				return HttpResponse.json({
+					tokenMetadata: mockTokenMetadata,
+				});
+			}),
+		);
+
+		const { result } = renderHook(() => useListTokenMetadata(defaultParams));
+
+		// 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 empty token IDs', async () => {
+		const emptyParams = {
+			...defaultParams,
+			tokenIds: [],
+		};
+
+		const { result } = renderHook(() => useListTokenMetadata(emptyParams));
+
+		// Should not trigger request with empty token IDs
+		expect(result.current.isLoading).toBe(false);
+		expect(result.current.data).toBeUndefined();
+		expect(result.current.error).toBeNull();
+	});
+
+	it('should handle disabled queries', async () => {
+		const disabledParams = {
+			...defaultParams,
+			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 API errors', async () => {
+		// Mock API error
+		server.use(
+			http.post('*/rpc/Metadata/GetTokenMetadata', () => {
+				return new HttpResponse(null, { status: 500 });
+			}),
+		);
+
+		const { result } = renderHook(() => useListTokenMetadata(defaultParams));
+
+		// Wait for error state
+		await waitFor(() => {
+			expect(result.current.isLoading).toBe(false);
+		});
+
+		expect(result.current.data).toBeUndefined();
+		expect(result.current.error).toBeTruthy();
+	});
+});

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';