@0xsequence/marketplace-sdk 0.5.1 → 0.5.3

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

@@ -0,0 +1,108 @@
+import { describe, expect, it } from 'vitest';
+import { useCountListingsForCollectible } from '../useCountListingsForCollectible';
+import { renderHook, waitFor } from '../../_internal/test-utils';
+import { zeroAddress } from 'viem';
+import { http, HttpResponse } from 'msw';
+import { server } from '../../_internal/test/setup';
+import { mockMarketplaceEndpoint } from '../../_internal/api/__mocks__/marketplace.msw';
+
+describe('useCountListingsForCollectible', () => {
+	const defaultArgs = {
+		chainId: '1',
+		collectionAddress: zeroAddress,
+		collectibleId: '1',
+		query: {},
+	};
+
+	it('should fetch listings count successfully', async () => {
+		const { result } = renderHook(() =>
+			useCountListingsForCollectible(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({ count: 1 });
+		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('GetCountOfListingsForCollectible'),
+				() => {
+					return HttpResponse.json(
+						{ error: { message: 'Failed to fetch listings count' } },
+						{ status: 500 },
+					);
+				},
+			),
+		);
+
+		const { result } = renderHook(() =>
+			useCountListingsForCollectible(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(() =>
+			useCountListingsForCollectible(defaultArgs),
+		);
+
+		// Wait for initial data
+		await waitFor(() => {
+			expect(result.current.isLoading).toBe(false);
+		});
+
+		// Change args and rerender
+		const newArgs = {
+			...defaultArgs,
+			collectionAddress:
+				'0x1234567890123456789012345678901234567890' as `0x${string}`,
+			collectibleId: '2',
+		};
+
+		rerender(() => useCountListingsForCollectible(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).toBeDefined();
+		expect(result.current.isSuccess).toBe(true);
+	});
+
+	it('should handle query options', async () => {
+		const argsWithQuery = {
+			...defaultArgs,
+			query: {
+				enabled: false,
+			},
+		};
+
+		const { result } = renderHook(() =>
+			useCountListingsForCollectible(argsWithQuery),
+		);
+
+		// Should not fetch when disabled
+		expect(result.current.isLoading).toBe(false);
+		expect(result.current.data).toBeUndefined();
+	});
+});

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

@@ -0,0 +1,129 @@
+import { describe, expect, it } from 'vitest';
+import { useCountOfCollectables } from '../useCountOfCollectables';
+import { renderHook, waitFor } from '../../_internal/test-utils';
+import { zeroAddress } from 'viem';
+import type { UseCountOfCollectablesArgs } from '../useCountOfCollectables';
+import { http, HttpResponse } from 'msw';
+import { mockMarketplaceEndpoint } from '../../_internal/api/__mocks__/marketplace.msw';
+import { OrderSide } from '../../_internal';
+import { server } from '../../_internal/test/setup';
+
+describe('useCountOfCollectables', () => {
+	const defaultArgs: UseCountOfCollectablesArgs = {
+		chainId: '1',
+		collectionAddress: zeroAddress,
+		query: {},
+	};
+
+	const defaultArgsWithFilter: UseCountOfCollectablesArgs = {
+		...defaultArgs,
+		filter: {
+			includeEmpty: true,
+		},
+		side: OrderSide.listing,
+	};
+
+	it('should fetch count of all collectables successfully', async () => {
+		const { result } = renderHook(() => useCountOfCollectables(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(100); // matches mock count from marketplace.msw.ts
+		expect(result.current.error).toBeNull();
+	});
+
+	it('should fetch filtered count of collectables successfully', async () => {
+		const { result } = renderHook(() =>
+			useCountOfCollectables(defaultArgsWithFilter),
+		);
+
+		// 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(50); // matches mock count from marketplace.msw.ts
+		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('GetCountOfAllCollectibles'), () => {
+				return HttpResponse.json(
+					{ error: { message: 'Failed to fetch count' } },
+					{ status: 500 },
+				);
+			}),
+		);
+
+		const { result } = renderHook(() => useCountOfCollectables(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(() =>
+			useCountOfCollectables(defaultArgs),
+		);
+
+		// Wait for initial data
+		await waitFor(() => {
+			expect(result.current.isLoading).toBe(false);
+		});
+
+		// Change args and rerender
+		const newArgs = {
+			...defaultArgs,
+			collectionAddress:
+				'0x1234567890123456789012345678901234567890' as `0x${string}`,
+		};
+
+		rerender(() => useCountOfCollectables(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).toBeDefined();
+		expect(result.current.isSuccess).toBe(true);
+	});
+
+	it('should handle undefined query params', async () => {
+		const argsWithoutQuery: UseCountOfCollectablesArgs = {
+			chainId: '1',
+			collectionAddress: zeroAddress,
+		};
+
+		const { result } = renderHook(() =>
+			useCountOfCollectables(argsWithoutQuery),
+		);
+
+		await waitFor(() => {
+			expect(result.current.isLoading).toBe(false);
+		});
+
+		expect(result.current.data).toBeDefined();
+		expect(result.current.error).toBeNull();
+	});
+});

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

@@ -0,0 +1,108 @@
+import { describe, expect, it } from 'vitest';
+import { useCountOffersForCollectible } from '../useCountOffersForCollectible';
+import { renderHook, waitFor } from '../../_internal/test-utils';
+import { zeroAddress } from 'viem';
+import { http, HttpResponse } from 'msw';
+import { server } from '../../_internal/test/setup';
+import { mockMarketplaceEndpoint } from '../../_internal/api/__mocks__/marketplace.msw';
+
+describe('useCountOffersForCollectible', () => {
+	const defaultArgs = {
+		chainId: '1',
+		collectionAddress: zeroAddress,
+		collectibleId: '1',
+		query: {},
+	};
+
+	it('should fetch offers count successfully', async () => {
+		const { result } = renderHook(() =>
+			useCountOffersForCollectible(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({ count: 1 });
+		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('GetCountOfOffersForCollectible'),
+				() => {
+					return HttpResponse.json(
+						{ error: { message: 'Failed to fetch offers count' } },
+						{ status: 500 },
+					);
+				},
+			),
+		);
+
+		const { result } = renderHook(() =>
+			useCountOffersForCollectible(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(() =>
+			useCountOffersForCollectible(defaultArgs),
+		);
+
+		// Wait for initial data
+		await waitFor(() => {
+			expect(result.current.isLoading).toBe(false);
+		});
+
+		// Change args and rerender
+		const newArgs = {
+			...defaultArgs,
+			collectionAddress:
+				'0x1234567890123456789012345678901234567890' as `0x${string}`,
+			collectibleId: '2',
+		};
+
+		rerender(() => useCountOffersForCollectible(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).toBeDefined();
+		expect(result.current.isSuccess).toBe(true);
+	});
+
+	it('should handle query options', async () => {
+		const argsWithQuery = {
+			...defaultArgs,
+			query: {
+				enabled: false,
+			},
+		};
+
+		const { result } = renderHook(() =>
+			useCountOffersForCollectible(argsWithQuery),
+		);
+
+		// Should not fetch when disabled
+		expect(result.current.isLoading).toBe(false);
+		expect(result.current.data).toBeUndefined();
+	});
+});

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

@@ -0,0 +1,176 @@
+import { describe, expect, it } from 'vitest';
+import { useCurrencies } from '../useCurrencies';
+import { renderHook, waitFor } from '../../_internal/test-utils';
+import { http, HttpResponse } from 'msw';
+import { server } from '../../_internal/test/setup';
+import {
+	mockCurrencies,
+	mockMarketplaceEndpoint,
+} from '../../_internal/api/__mocks__/marketplace.msw';
+import { mockConfig } from '../options/__mocks__/marketplaceConfig.msw';
+
+describe('useCurrencies', () => {
+	const defaultArgs = {
+		chainId: '1',
+	};
+
+	it('should fetch currencies successfully', async () => {
+		const { result } = renderHook(() => useCurrencies(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(mockCurrencies);
+		expect(result.current.error).toBeNull();
+	});
+
+	it('should filter out native currency when includeNativeCurrency is false', async () => {
+		const argsWithoutNative = {
+			...defaultArgs,
+			includeNativeCurrency: false,
+		};
+
+		const { result } = renderHook(() => useCurrencies(argsWithoutNative));
+
+		await waitFor(() => {
+			expect(result.current.isLoading).toBe(false);
+		});
+
+		expect(result.current.data).toEqual(
+			mockCurrencies.filter((currency) => !currency.nativeCurrency),
+		);
+	});
+
+	it('should filter currencies by collection address', async () => {
+		const args = {
+			...defaultArgs,
+			collectionAddress: mockConfig.collections[1].address,
+		} satisfies Parameters<typeof useCurrencies>[0];
+
+		const { result } = renderHook(() => useCurrencies(args));
+
+		await waitFor(() => {
+			expect(result.current.isLoading).toBe(false);
+		});
+
+		const currencyAddresses = result.current.data?.map(
+			(c) => c.contractAddress,
+		);
+		expect(currencyAddresses).toEqual(
+			mockConfig.collections[1].currencyOptions,
+		);
+	});
+
+	it('should handle error states', async () => {
+		// Override the handler for this test to return an error
+		server.use(
+			http.post(mockMarketplaceEndpoint('ListCurrencies'), () => {
+				return HttpResponse.json(
+					{ error: { message: 'Failed to fetch currencies' } },
+					{ status: 500 },
+				);
+			}),
+		);
+
+		const { result } = renderHook(() => useCurrencies(defaultArgs));
+
+		await waitFor(() => {
+			expect(result.current.isError).toBe(true);
+		});
+
+		expect(result.current.error).toBeDefined();
+		expect(result.current.data).toBeUndefined();
+	});
+
+	it('should refetch when chainId changes', async () => {
+		const { result, rerender } = renderHook(() => useCurrencies(defaultArgs));
+
+		// Wait for initial data
+		await waitFor(() => {
+			expect(result.current.isLoading).toBe(false);
+		});
+
+		// Change chainId and rerender
+		const newArgs = {
+			...defaultArgs,
+			chainId: '5',
+		};
+
+		rerender(() => useCurrencies(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).toBeDefined();
+		expect(result.current.isSuccess).toBe(true);
+	});
+
+	it('should handle query options', async () => {
+		const argsWithQuery = {
+			...defaultArgs,
+			query: {
+				enabled: false,
+			},
+		};
+
+		const { result } = renderHook(() => useCurrencies(argsWithQuery));
+
+		// Should not fetch when disabled
+		expect(result.current.isLoading).toBe(false);
+		expect(result.current.data).toBeUndefined();
+	});
+
+	it('should handle combined filters', async () => {
+		const argsWithCombinedFilters = {
+			...defaultArgs,
+			includeNativeCurrency: false,
+			currencyOptions: [
+				'0x1234567890123456789012345678901234567890', // USDC address from mock
+			],
+		};
+
+		const { result } = renderHook(() => useCurrencies(argsWithCombinedFilters));
+
+		await waitFor(() => {
+			expect(result.current.isLoading).toBe(false);
+		});
+
+		console.log('result.current.data', result.current.data);
+
+		// Should only include non-native currencies from the currencyOptions list
+		expect(result.current.data).toEqual(
+			mockCurrencies.filter(
+				(currency) =>
+					!currency.nativeCurrency &&
+					currency.contractAddress.toLowerCase() ===
+						'0x1234567890123456789012345678901234567890'.toLowerCase(),
+			),
+		);
+	});
+
+	it('should handle collection filter', async () => {
+		const args = {
+			...defaultArgs,
+			includeNativeCurrency: false,
+			collectionAddress: '0x1234567890123456789012345678901234567890',
+		} satisfies Parameters<typeof useCurrencies>[0];
+
+		const { result } = renderHook(() => useCurrencies(args));
+
+		await waitFor(() => {
+			expect(result.current.isLoading).toBe(false);
+		});
+
+		expect(result.current.data).toBeDefined();
+	});
+});

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

@@ -0,0 +1,153 @@
+import { beforeEach, describe, expect, it } from 'vitest';
+import { useCurrency } from '../useCurrency';
+import { renderHook, waitFor } from '../../_internal/test-utils';
+import { http, HttpResponse } from 'msw';
+import { server } from '../../_internal/test/setup';
+import {
+	mockCurrencies,
+	mockMarketplaceEndpoint,
+} from '../../_internal/api/__mocks__/marketplace.msw';
+import { getQueryClient } from '../../_internal';
+import { currencyKeys } from '../../_internal';
+
+describe('useCurrency', () => {
+	const defaultArgs = {
+		chainId: '1',
+		currencyAddress: '0x1234567890123456789012345678901234567890', // USDC address from mock
+		query: {},
+	};
+
+	// Clear query cache before each test
+	beforeEach(() => {
+		const queryClient = getQueryClient();
+		queryClient.clear();
+	});
+
+	it('should fetch currency successfully when cache is empty', async () => {
+		const { result } = renderHook(() => useCurrency(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(
+			mockCurrencies.find(
+				(currency) =>
+					currency.contractAddress.toLowerCase() ===
+					defaultArgs.currencyAddress.toLowerCase(),
+			),
+		);
+		expect(result.current.error).toBeNull();
+	});
+
+	it('should use cached currencies when available', async () => {
+		// Prefill the cache with currencies
+		const queryClient = getQueryClient();
+		await queryClient.prefetchQuery({
+			queryKey: [...currencyKeys.lists, defaultArgs.chainId],
+			queryFn: () => mockCurrencies,
+		});
+
+		const { result } = renderHook(() => useCurrency(defaultArgs));
+
+		await waitFor(() => {
+			expect(result.current.isLoading).toBe(false);
+		});
+
+		// Should resolve using cached data
+		expect(result.current.data).toEqual(
+			mockCurrencies.find(
+				(currency) =>
+					currency.contractAddress.toLowerCase() ===
+					defaultArgs.currencyAddress.toLowerCase(),
+			),
+		);
+	});
+
+	it('should handle currency not found error', async () => {
+		const argsWithInvalidAddress = {
+			...defaultArgs,
+			currencyAddress: '0xdeadbeefdeadbeefdeadbeefdeadbeefdeadbeef',
+		};
+
+		const { result } = renderHook(() => useCurrency(argsWithInvalidAddress));
+
+		await waitFor(() => {
+			expect(result.current.isError).toBe(true);
+		});
+
+		expect(result.current.error).toBeDefined();
+		if (result.current.error instanceof Error) {
+			expect(result.current.error.message).toBe('Currency not found');
+		}
+		expect(result.current.data).toBeUndefined();
+	});
+
+	it('should handle API error states', async () => {
+		// Override the handler for this test to return an error
+		server.use(
+			http.post(mockMarketplaceEndpoint('ListCurrencies'), () => {
+				return HttpResponse.json(
+					{ error: { message: 'Failed to fetch currencies' } },
+					{ status: 500 },
+				);
+			}),
+		);
+
+		const { result } = renderHook(() => useCurrency(defaultArgs));
+
+		await waitFor(() => {
+			expect(result.current.isError).toBe(true);
+		});
+
+		expect(result.current.error).toBeDefined();
+		expect(result.current.data).toBeUndefined();
+	});
+
+	it('should refetch when chainId changes', async () => {
+		const { result, rerender } = renderHook(() => useCurrency(defaultArgs));
+
+		// Wait for initial data
+		await waitFor(() => {
+			expect(result.current.isLoading).toBe(false);
+		});
+
+		// Change chainId and rerender
+		const newArgs = {
+			...defaultArgs,
+			chainId: '5',
+		};
+
+		rerender(() => useCurrency(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).toBeDefined();
+		expect(result.current.isSuccess).toBe(true);
+	});
+
+	it('should handle query options', async () => {
+		const argsWithQuery = {
+			...defaultArgs,
+			query: {
+				enabled: false,
+			},
+		};
+
+		const { result } = renderHook(() => useCurrency(argsWithQuery));
+
+		// Should not fetch when disabled
+		expect(result.current.isLoading).toBe(false);
+		expect(result.current.data).toBeUndefined();
+	});
+});