@0xsequence/marketplace-sdk 0.9.0 → 0.10.0

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

@@ -138,4 +138,21 @@ describe('useCollectionBalanceDetails', () => {
 
 		expect(result.current.data?.balances[0].contractAddress).toBe(zeroAddress);
 	});
+
+	it('should handle disabled query when required params are missing', async () => {
+		const { result } = renderHook(() =>
+			useCollectionBalanceDetails({
+				chainId: 1,
+				filter: {
+					accountAddresses: [], // Empty array should disable the query
+					omitNativeBalances: true,
+				},
+			}),
+		);
+
+		// Query should be disabled when accountAddresses is empty
+		expect(result.current.isLoading).toBe(false);
+		expect(result.current.data).toBeUndefined();
+		expect(result.current.error).toBeNull();
+	});
 });

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

@@ -45,7 +45,9 @@ describe('useCollectionDetailsPolling', () => {
 		);
 
 		const { result } = renderHook(() =>
-			useCollectionDetailsPolling(defaultArgs),
+			useCollectionDetailsPolling({
+				...defaultArgs,
+			}),
 		);
 
 		// Initially loading
@@ -90,7 +92,11 @@ describe('useCollectionDetailsPolling', () => {
 			}),
 		);
 
-		renderHook(() => useCollectionDetailsPolling(defaultArgs));
+		renderHook(() =>
+			useCollectionDetailsPolling({
+				...defaultArgs,
+			}),
+		);
 
 		// Fast-forward through all attempts
 		for (let i = 0; i < 30; i++) {
@@ -116,7 +122,9 @@ describe('useCollectionDetailsPolling', () => {
 		);
 
 		const { result } = renderHook(() =>
-			useCollectionDetailsPolling(defaultArgs),
+			useCollectionDetailsPolling({
+				...defaultArgs,
+			}),
 		);
 
 		await waitFor(() => {

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

@@ -6,11 +6,11 @@ import {
 	mockCurrencies,
 	mockMarketplaceEndpoint,
 } from '../../_internal/api/__mocks__/marketplace.msw';
-import type { UseConvertPriceToUSDArgs } from '../useConvertPriceToUSD';
+import type { UseConvertPriceToUSDParams } from '../useConvertPriceToUSD';
 import { useConvertPriceToUSD } from '../useConvertPriceToUSD';
 
 describe('useConvertPriceToUSD', () => {
-	const defaultArgs: UseConvertPriceToUSDArgs = {
+	const defaultArgs: UseConvertPriceToUSDParams = {
 		chainId: 1,
 		currencyAddress: zeroAddress,
 		amountRaw: '1000000000000000000', // 1 ETH
@@ -113,7 +113,7 @@ describe('useConvertPriceToUSD', () => {
 		);
 
 		const { result, rerender } = renderHook(
-			(args: UseConvertPriceToUSDArgs = defaultArgs) =>
+			(args: UseConvertPriceToUSDParams = defaultArgs) =>
 				useConvertPriceToUSD(args),
 		);
 

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

@@ -63,11 +63,15 @@ describe('useCurrencyBalance', () => {
 		`);
 	});
 
-	it('should return skipToken when required parameters are missing', () => {
+	it('should handle disabled query when enabled is false', () => {
 		const { result } = renderHook(() =>
-			// @ts-expect-error - missing params
 			useCurrencyBalance({
-				chainId: undefined,
+				chainId: 1,
+				currencyAddress: zeroAddress,
+				userAddress: USDC_HOLDER,
+				query: {
+					enabled: false,
+				},
 			}),
 		);
 

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

@@ -3,11 +3,11 @@ import { HttpResponse, http } from 'msw';
 import { zeroAddress } from 'viem';
 import { describe, expect, it } from 'vitest';
 import { mockMetadataEndpoint } from '../../_internal/api/__mocks__/metadata.msw';
-import type { UseFiltersArgs } from '../useFilters';
+import type { UseFiltersParams } from '../useFilters';
 import { useFilters } from '../useFilters';
 
 describe('useFilters', () => {
-	const defaultArgs: UseFiltersArgs = {
+	const defaultArgs: UseFiltersParams = {
 		chainId: 1,
 		collectionAddress: zeroAddress,
 	};

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

@@ -0,0 +1,111 @@
+import { renderHook, server, waitFor } from '@test';
+import { HttpResponse, http } from 'msw';
+import { zeroAddress } from 'viem';
+import { describe, expect, it } from 'vitest';
+import { mockIndexerEndpoint } from '../../_internal/api/__mocks__/indexer.msw';
+import type { UseGetTokenRangesParams } from '../useGetTokenRanges';
+import { useGetTokenRanges } from '../useGetTokenRanges';
+
+describe('useGetTokenRanges', () => {
+	const defaultArgs: UseGetTokenRangesParams = {
+		chainId: 1,
+		collectionAddress: zeroAddress,
+	};
+
+	it('should fetch token ranges successfully', async () => {
+		const { result } = renderHook(() => useGetTokenRanges(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);
+		});
+
+		expect(result.current.data).toBeDefined();
+		expect(result.current.data?.tokenIDRanges).toBeDefined();
+		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(mockIndexerEndpoint('GetTokenIDRanges'), () => {
+				return HttpResponse.json(
+					{ error: { message: 'Failed to fetch token ranges' } },
+					{ status: 500 },
+				);
+			}),
+		);
+
+		const { result } = renderHook(() => useGetTokenRanges(defaultArgs));
+
+		// Wait for the error state
+		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(() =>
+			useGetTokenRanges(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(() => useGetTokenRanges(newArgs));
+
+		// Wait for new data
+		await waitFor(() => {
+			expect(result.current.data).toBeDefined();
+		});
+
+		expect(result.current.isSuccess).toBe(true);
+	});
+
+	it('should handle disabled query when required params are missing', async () => {
+		const { result } = renderHook(() =>
+			useGetTokenRanges({
+				chainId: 0, // Invalid chainId should disable the query
+				collectionAddress: zeroAddress,
+			}),
+		);
+
+		// Query should be disabled when chainId is invalid
+		expect(result.current.isLoading).toBe(false);
+		expect(result.current.data).toBeUndefined();
+		expect(result.current.error).toBeNull();
+	});
+
+	it('should handle enabled/disabled state from query options', async () => {
+		const { result } = renderHook(() =>
+			useGetTokenRanges({
+				...defaultArgs,
+				query: {
+					enabled: false, // Explicitly disable the query
+				},
+			}),
+		);
+
+		// Query should be disabled
+		expect(result.current.isLoading).toBe(false);
+		expect(result.current.data).toBeUndefined();
+		expect(result.current.error).toBeNull();
+		expect(result.current.fetchStatus).toBe('idle');
+	});
+});

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

@@ -1,50 +1,23 @@
 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 defaultParams = {
-		chainId: 1,
-		contractAddress: '0x1234567890123456789012345678901234567890',
+	const defaultArgs: UseListTokenMetadataParams = {
+		chainId: mockEthCollection.chainId,
+		contractAddress: mockEthCollection.address,
 		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));
+		const { result } = renderHook(() => useListTokenMetadata(defaultArgs));
 
 		// Initially loading
 		expect(result.current.isLoading).toBe(true);
@@ -56,27 +29,35 @@ describe('useListTokenMetadata', () => {
 		});
 
 		// Verify the data matches our mock
-		expect(result.current.data).toEqual(mockTokenMetadata);
+		expect(result.current.data).toEqual([mockTokenMetadata]);
 		expect(result.current.error).toBeNull();
 	});
 
-	it('should handle empty token IDs', async () => {
-		const emptyParams = {
-			...defaultParams,
-			tokenIds: [],
-		};
+	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(emptyParams));
+		const { result } = renderHook(() => useListTokenMetadata(defaultArgs));
+
+		// Wait for error to be set
+		await waitFor(() => {
+			expect(result.current.isError).toBe(true);
+		});
 
-		// Should not trigger request with empty token IDs
-		expect(result.current.isLoading).toBe(false);
 		expect(result.current.data).toBeUndefined();
-		expect(result.current.error).toBeNull();
+		expect(result.current.error).toBeTruthy();
 	});
 
-	it('should handle disabled queries', async () => {
+	it('should handle disabled queries', () => {
 		const disabledParams = {
-			...defaultParams,
+			...defaultArgs,
 			query: {
 				enabled: false,
 			},
@@ -90,22 +71,67 @@ describe('useListTokenMetadata', () => {
 		expect(result.current.error).toBeNull();
 	});
 
-	it('should handle API errors', async () => {
-		// Mock API error
+	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('*/rpc/Metadata/GetTokenMetadata', () => {
-				return new HttpResponse(null, { status: 500 });
+			http.post(mockMetadataEndpoint('GetTokenMetadata'), async (request) => {
+				capturedRequest = await request.request.json();
+				return HttpResponse.json({
+					tokenMetadata: [mockTokenMetadata],
+				});
 			}),
 		);
 
-		const { result } = renderHook(() => useListTokenMetadata(defaultParams));
+		const customParams = {
+			chainId: 137,
+			contractAddress: '0x1234567890123456789012345678901234567890',
+			tokenIds: ['10', '20', '30'],
+		};
+
+		const { result } = renderHook(() => useListTokenMetadata(customParams));
 
-		// Wait for error state
 		await waitFor(() => {
 			expect(result.current.isLoading).toBe(false);
 		});
 
-		expect(result.current.data).toBeUndefined();
-		expect(result.current.error).toBeTruthy();
+		// Verify the API was called with correct parameters
+		expect(capturedRequest).toEqual({
+			chainID: '137',
+			contractAddress: '0x1234567890123456789012345678901234567890',
+			tokenIDs: ['10', '20', '30'],
+		});
 	});
 });