@0xsequence/marketplace-sdk 0.5.1 → 0.5.3

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

@@ -0,0 +1,120 @@
+import { describe, expect, it } from 'vitest';
+import { useCollectible } from '../useCollectible';
+import { renderHook, waitFor } from '../../_internal/test-utils';
+import { zeroAddress } from 'viem';
+import type { UseCollectibleArgs } from '../useCollectible';
+import { http, HttpResponse } from 'msw';
+import {
+	mockTokenMetadata,
+	mockMetadataEndpoint,
+} from '../../_internal/api/__mocks__/metadata.msw';
+import { server } from '../../_internal/test/setup';
+
+describe('useCollectible', () => {
+	const defaultArgs: UseCollectibleArgs = {
+		chainId: '1',
+		collectionAddress: zeroAddress,
+		collectibleId: '1',
+		query: {},
+	};
+
+	it('should fetch collectible data successfully', async () => {
+		const { result } = renderHook(() => useCollectible(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 collectible' } },
+					{ status: 500 },
+				);
+			}),
+		);
+
+		const { result } = renderHook(() => useCollectible(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(() => useCollectible(defaultArgs));
+
+		// Wait for initial data
+		await waitFor(() => {
+			expect(result.current.isLoading).toBe(false);
+		});
+
+		// Change args and rerender
+		const newArgs = {
+			...defaultArgs,
+			collectibleId: '2',
+			collectionAddress:
+				'0x1234567890123456789012345678901234567890' as `0x${string}`,
+		};
+
+		rerender(() => useCollectible(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: UseCollectibleArgs = {
+			chainId: '1',
+			collectionAddress: zeroAddress,
+			collectibleId: '1',
+			query: {},
+		};
+
+		const { result } = renderHook(() => useCollectible(argsWithoutQuery));
+
+		await waitFor(() => {
+			expect(result.current.isLoading).toBe(false);
+		});
+
+		expect(result.current.data).toBeDefined();
+		expect(result.current.error).toBeNull();
+	});
+
+	it('should validate input parameters', async () => {
+		const invalidArgs: UseCollectibleArgs = {
+			...defaultArgs,
+			// @ts-expect-error
+			chainId: {}, // Using an object instead of a string/number will fail validation
+		};
+
+		const { result } = renderHook(() => useCollectible(invalidArgs));
+
+		await waitFor(() => {
+			expect(result.current.isError).toBe(true);
+		});
+
+		expect(result.current.error).toBeDefined();
+	});
+});

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

@@ -0,0 +1,101 @@
+import { describe, expect, it } from 'vitest';
+import { useCollection } from '../useCollection';
+import { renderHook, waitFor } from '../../_internal/test-utils';
+import { zeroAddress } from 'viem';
+import type { UseCollectionArgs } from '../useCollection';
+import { http, HttpResponse } from 'msw';
+import {
+	mockContractInfo,
+	mockMetadataEndpoint,
+} from '../../_internal/api/__mocks__/metadata.msw';
+import { server } from '../../_internal/test/setup';
+
+describe('useCollection', () => {
+	const defaultArgs: UseCollectionArgs = {
+		chainId: '1',
+		collectionAddress: zeroAddress,
+		query: {},
+	};
+
+	it('should fetch collection data successfully', async () => {
+		const { result } = renderHook(() => useCollection(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(mockContractInfo);
+		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('GetContractInfo'), () => {
+				return HttpResponse.json(
+					{ error: { message: 'Failed to fetch collection' } },
+					{ status: 500 },
+				);
+			}),
+		);
+
+		const { result } = renderHook(() => useCollection(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(() => useCollection(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(() => useCollection(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: UseCollectionArgs = {
+			chainId: '1',
+			collectionAddress: zeroAddress,
+			query: {},
+		};
+
+		const { result } = renderHook(() => useCollection(argsWithoutQuery));
+
+		await waitFor(() => {
+			expect(result.current.isLoading).toBe(false);
+		});
+
+		expect(result.current.data).toBeDefined();
+		expect(result.current.error).toBeNull();
+	});
+});

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

@@ -0,0 +1,175 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { waitFor } from '@testing-library/react';
+import { useCollectionBalanceDetails } from '../useCollectionBalanceDetails';
+import { mockTokenBalance } from '../../_internal/api/__mocks__/indexer.msw';
+import { zeroAddress } from 'viem';
+import { renderHook } from '../../_internal/test-utils';
+import { http, HttpResponse } from 'msw';
+import { server } from '../../_internal/test/setup';
+import { mockIndexerEndpoint } from '../../_internal/api/__mocks__/indexer.msw';
+
+describe('useCollectionBalanceDetails', () => {
+	beforeEach(() => {
+		vi.clearAllMocks();
+		server.resetHandlers();
+	});
+
+	afterEach(() => {
+		server.resetHandlers();
+	});
+
+	const defaultArgs = {
+		chainId: 1,
+		filter: {
+			accountAddresses: [zeroAddress],
+			omitNativeBalances: true,
+		},
+	};
+
+	it('should fetch balance details successfully', async () => {
+		const { result } = renderHook(() =>
+			useCollectionBalanceDetails(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?.balances[0]).toEqual(mockTokenBalance);
+		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('GetTokenBalancesDetails'), () => {
+				return HttpResponse.json(
+					{ error: { message: 'Failed to fetch balances' } },
+					{ status: 500 },
+				);
+			}),
+		);
+
+		const { result } = renderHook(() =>
+			useCollectionBalanceDetails(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(() =>
+			useCollectionBalanceDetails(defaultArgs),
+		);
+
+		// Wait for initial data
+		await waitFor(() => {
+			expect(result.current.isLoading).toBe(false);
+		});
+
+		// Change args and rerender
+		const newArgs = {
+			...defaultArgs,
+			filter: {
+				...defaultArgs.filter,
+				accountAddresses: [
+					'0x1234567890123456789012345678901234567890' as `0x${string}`,
+				],
+			},
+		};
+
+		rerender(() => useCollectionBalanceDetails(newArgs));
+
+		// Wait for new data
+		await waitFor(() => {
+			expect(result.current.data).toBeDefined();
+		});
+
+		expect(result.current.isSuccess).toBe(true);
+	});
+
+	it('should handle multiple accounts', async () => {
+		const multipleAccountsArgs = {
+			...defaultArgs,
+			filter: {
+				...defaultArgs.filter,
+				accountAddresses: [
+					zeroAddress,
+					'0x1234567890123456789012345678901234567890' as `0x${string}`,
+				],
+			},
+		};
+
+		const { result } = renderHook(() =>
+			useCollectionBalanceDetails(multipleAccountsArgs),
+		);
+
+		await waitFor(() => {
+			expect(result.current.isSuccess).toBe(true);
+		});
+
+		expect(result.current.data?.balances).toHaveLength(2);
+		expect(result.current.data?.balances).toEqual(
+			expect.arrayContaining([mockTokenBalance, mockTokenBalance]),
+		);
+	});
+
+	it('should handle contract whitelist filter', async () => {
+		const whitelistArgs = {
+			...defaultArgs,
+			filter: {
+				...defaultArgs.filter,
+				contractWhitelist: [zeroAddress],
+			},
+		};
+
+		const { result } = renderHook(() =>
+			useCollectionBalanceDetails(whitelistArgs),
+		);
+
+		await waitFor(() => {
+			expect(result.current.isSuccess).toBe(true);
+		});
+
+		expect(result.current.data?.balances[0].contractAddress).toBe(zeroAddress);
+	});
+
+	it('should handle validation errors', () => {
+		expect(() =>
+			renderHook(() =>
+				useCollectionBalanceDetails({
+					chainId: 'invalid-chain-id' as unknown as number,
+					filter: {
+						accountAddresses: [zeroAddress],
+						omitNativeBalances: true,
+					},
+				}),
+			),
+		).toThrow();
+
+		expect(() =>
+			renderHook(() =>
+				useCollectionBalanceDetails({
+					chainId: 1,
+					filter: {
+						accountAddresses: ['invalid-address' as unknown as `0x${string}`],
+						omitNativeBalances: true,
+					},
+				}),
+			),
+		).toThrow();
+	});
+});

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

@@ -0,0 +1,82 @@
+import { describe, expect, it } from 'vitest';
+import { useCollectionDetails } from '../useCollectionDetails';
+import { renderHook, waitFor } from '../../_internal/test-utils';
+import { zeroAddress } from 'viem';
+import { http, HttpResponse } from 'msw';
+import { mockCollection } from '../../_internal/api/__mocks__/marketplace.msw';
+import { server } from '../../_internal/test/setup';
+import { mockMarketplaceEndpoint } from '../../_internal/api/__mocks__/marketplace.msw';
+
+describe('useCollectionDetails', () => {
+	const defaultArgs = {
+		chainId: 1,
+		collectionAddress: zeroAddress,
+	};
+
+	it('should fetch collection details successfully', async () => {
+		const { result } = renderHook(() => useCollectionDetails(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(mockCollection);
+		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('GetCollectionDetail'), () => {
+				return HttpResponse.json(
+					{ error: { message: 'Failed to fetch collection details' } },
+					{ status: 500 },
+				);
+			}),
+		);
+
+		const { result } = renderHook(() => useCollectionDetails(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(() =>
+			useCollectionDetails(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(() => useCollectionDetails(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);
+	});
+});

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

@@ -0,0 +1,133 @@
+import { describe, expect, it, vi, beforeEach, afterEach } from 'vitest';
+import { useCollectionDetailsPolling } from '../useCollectionDetailsPolling';
+import { renderHook, waitFor } from '../../_internal/test-utils';
+import { zeroAddress } from 'viem';
+import { http, HttpResponse } from 'msw';
+import { mockCollection } from '../../_internal/api/__mocks__/marketplace.msw';
+import { server } from '../../_internal/test/setup';
+import { mockMarketplaceEndpoint } from '../../_internal/api/__mocks__/marketplace.msw';
+import { CollectionStatus } from '../../_internal/api/marketplace.gen';
+
+describe('useCollectionDetailsPolling', () => {
+	const defaultArgs = {
+		chainId: 1,
+		collectionAddress: zeroAddress,
+	};
+
+	beforeEach(() => {
+		vi.useFakeTimers({ shouldAdvanceTime: true });
+	});
+
+	afterEach(() => {
+		vi.useRealTimers();
+		server.resetHandlers();
+	});
+
+	it('should poll collection details until terminal state is reached', async () => {
+		// Mock initial syncing state
+		const syncingCollection = {
+			...mockCollection,
+			status: CollectionStatus.syncing_metadata,
+		};
+		let requestCount = 0;
+
+		server.use(
+			http.post(mockMarketplaceEndpoint('GetCollectionDetail'), () => {
+				requestCount++;
+				// Return syncing state for first request, then active state
+				const response =
+					requestCount === 1
+						? { collection: syncingCollection }
+						: {
+								collection: {
+									...mockCollection,
+									status: CollectionStatus.active,
+								},
+							};
+				return HttpResponse.json(response);
+			}),
+		);
+
+		const { result } = renderHook(() =>
+			useCollectionDetailsPolling(defaultArgs),
+		);
+
+		// Initially loading
+		expect(result.current.isLoading).toBe(true);
+		expect(result.current.data).toBeUndefined();
+
+		// Wait for first data fetch
+		await waitFor(() => {
+			expect(result.current.data).toBeDefined();
+		});
+
+		// Should be in syncing state
+		expect(result.current.data?.status).toBe(CollectionStatus.syncing_metadata);
+
+		// Advance timer and run pending timers to trigger next poll
+		await vi.advanceTimersByTimeAsync(2000);
+		await vi.runOnlyPendingTimersAsync();
+
+		// Wait for second fetch to complete
+		await waitFor(() => {
+			expect(result.current.data?.status).toBe(CollectionStatus.active);
+		});
+
+		// Verify polling stops after reaching terminal state
+		const currentRequestCount = requestCount;
+		await vi.advanceTimersByTimeAsync(2000);
+		await vi.runOnlyPendingTimersAsync();
+		expect(requestCount).toBe(currentRequestCount); // Should not make additional requests
+	}, 10000);
+
+	it('should stop polling after max attempts', async () => {
+		const syncingCollection = {
+			...mockCollection,
+			status: CollectionStatus.syncing_metadata,
+		};
+		let requestCount = 0;
+
+		server.use(
+			http.post(mockMarketplaceEndpoint('GetCollectionDetail'), () => {
+				requestCount++;
+				return HttpResponse.json({ collection: syncingCollection });
+			}),
+		);
+
+		renderHook(() => useCollectionDetailsPolling(defaultArgs));
+
+		// Fast-forward through all attempts
+		for (let i = 0; i < 30; i++) {
+			await vi.advanceTimersByTimeAsync(2000);
+			await vi.runOnlyPendingTimersAsync();
+		}
+
+		const finalCount = requestCount;
+		await vi.advanceTimersByTimeAsync(30000);
+		await vi.runOnlyPendingTimersAsync();
+		expect(requestCount).toBe(finalCount); // Should not increase after max attempts
+		expect(requestCount).toBeLessThanOrEqual(30); // Should not exceed MAX_ATTEMPTS
+	}, 10000);
+
+	it('should handle error states', async () => {
+		server.use(
+			http.post(mockMarketplaceEndpoint('GetCollectionDetail'), () => {
+				return HttpResponse.json(
+					{ error: { message: 'Failed to fetch collection details' } },
+					{ status: 500 },
+				);
+			}),
+		);
+
+		const { result } = renderHook(() =>
+			useCollectionDetailsPolling(defaultArgs),
+		);
+
+		await waitFor(() => {
+			expect(result.current.isError).toBe(true);
+		});
+
+		expect(result.current.error).toBeDefined();
+		expect(result.current.data).toBeUndefined();
+	}, 10000);
+});