@0xsequence/marketplace-sdk 0.5.2 → 0.5.3

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

@@ -0,0 +1,181 @@
+import { describe, expect, it, vi, beforeEach } from 'vitest';
+import { useGenerateSellTransaction } from '../useGenerateSellTransaction';
+import { renderHook, waitFor } from '../../_internal/test-utils';
+import { zeroAddress } from 'viem';
+import { http, HttpResponse } from 'msw';
+import {
+	mockSteps,
+	mockMarketplaceEndpoint,
+} from '../../_internal/api/__mocks__/marketplace.msw';
+import { server } from '../../_internal/test/setup';
+import {
+	ContractType,
+	OrderbookKind,
+	MarketplaceKind,
+} from '../../_internal/api/marketplace.gen';
+import { useConfig } from '../useConfig';
+import type { SdkConfig } from '../../../types';
+
+// Mock useConfig hook
+vi.mock('../useConfig');
+
+describe('useGenerateSellTransaction', () => {
+	const mockOnSuccess = vi.fn();
+
+	const mockConfig: SdkConfig = {
+		projectId: 'test-project',
+		projectAccessKey: 'test-access-key',
+	};
+
+	const mockOrderData = {
+		orderId: '1',
+		quantity: '1',
+	};
+
+	const mockTransactionProps = {
+		collectionAddress: zeroAddress,
+		seller: zeroAddress,
+		contractType: ContractType.ERC721,
+		orderbook: OrderbookKind.sequence_marketplace_v2,
+		marketplace: MarketplaceKind.sequence_marketplace_v2,
+		ordersData: [mockOrderData],
+		additionalFees: [],
+	};
+
+	const defaultArgs = {
+		chainId: '1' as const,
+		onSuccess: mockOnSuccess,
+	};
+
+	beforeEach(() => {
+		vi.clearAllMocks();
+
+		// Set up the mock implementation for useConfig
+		vi.mocked(useConfig).mockReturnValue(mockConfig);
+
+		// Mock default steps response
+		server.use(
+			http.post(mockMarketplaceEndpoint('GenerateSellTransaction'), () => {
+				return HttpResponse.json({
+					steps: mockSteps,
+				});
+			}),
+		);
+	});
+
+	it('should generate sell transaction successfully', async () => {
+		const { result } = renderHook(() =>
+			useGenerateSellTransaction(defaultArgs),
+		);
+
+		await result.current.generateSellTransactionAsync(mockTransactionProps);
+
+		expect(mockOnSuccess).toHaveBeenCalledWith(
+			mockSteps,
+			mockTransactionProps,
+			undefined,
+		);
+	});
+
+	it('should handle async generation with await', async () => {
+		const { result } = renderHook(() =>
+			useGenerateSellTransaction(defaultArgs),
+		);
+
+		const steps =
+			await result.current.generateSellTransactionAsync(mockTransactionProps);
+
+		expect(steps).toEqual(mockSteps);
+	});
+
+	it('should handle non-async generation with callback', async () => {
+		const { result } = renderHook(() =>
+			useGenerateSellTransaction(defaultArgs),
+		);
+
+		result.current.generateSellTransaction(mockTransactionProps);
+
+		await waitFor(() => {
+			expect(mockOnSuccess).toHaveBeenCalledWith(
+				mockSteps,
+				mockTransactionProps,
+				undefined,
+			);
+		});
+	});
+
+	it('should handle API errors', async () => {
+		// Mock error response
+		server.use(
+			http.post(mockMarketplaceEndpoint('GenerateSellTransaction'), () => {
+				return new HttpResponse(null, { status: 500 });
+			}),
+		);
+
+		const { result } = renderHook(() =>
+			useGenerateSellTransaction(defaultArgs),
+		);
+
+		await expect(
+			result.current.generateSellTransactionAsync(mockTransactionProps),
+		).rejects.toThrow();
+
+		expect(mockOnSuccess).not.toHaveBeenCalled();
+	});
+
+	it('should use provided config from useConfig hook', async () => {
+		const customConfig: SdkConfig = {
+			projectId: 'custom-project',
+			projectAccessKey: 'custom-access-key',
+		};
+
+		let requestHeaders: Headers | undefined;
+
+		server.use(
+			http.post(
+				mockMarketplaceEndpoint('GenerateSellTransaction'),
+				async ({ request }) => {
+					requestHeaders = request.headers;
+					return HttpResponse.json({ steps: mockSteps });
+				},
+			),
+		);
+
+		vi.mocked(useConfig).mockReturnValue(customConfig);
+
+		const { result } = renderHook(() =>
+			useGenerateSellTransaction(defaultArgs),
+		);
+		await result.current.generateSellTransactionAsync(mockTransactionProps);
+
+		expect(requestHeaders?.get('x-access-key')).toBe(
+			customConfig.projectAccessKey,
+		);
+	});
+
+	it('should handle invalid sell data', async () => {
+		const invalidOrderData = {
+			orderId: '1',
+			quantity: 'invalid-quantity',
+		};
+
+		server.use(
+			http.post(mockMarketplaceEndpoint('GenerateSellTransaction'), () => {
+				return new HttpResponse(null, { status: 400 });
+			}),
+		);
+
+		const { result } = renderHook(() =>
+			useGenerateSellTransaction(defaultArgs),
+		);
+
+		await expect(
+			result.current.generateSellTransactionAsync({
+				...mockTransactionProps,
+				ordersData: [invalidOrderData],
+			}),
+		).rejects.toThrow();
+
+		expect(mockOnSuccess).not.toHaveBeenCalled();
+	});
+});

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

@@ -0,0 +1,118 @@
+import { describe, expect, it } from 'vitest';
+import { useHighestOffer } from '../useHighestOffer';
+import { renderHook, waitFor } from '../../_internal/test-utils';
+import { zeroAddress } from 'viem';
+import type { UseHighestOfferArgs } from '../useHighestOffer';
+import { http, HttpResponse } from 'msw';
+import { server } from '../../_internal/test/setup';
+import {
+	mockOrder,
+	mockMarketplaceEndpoint,
+} from '../../_internal/api/__mocks__/marketplace.msw';
+
+describe('useHighestOffer', () => {
+	const defaultArgs: UseHighestOfferArgs = {
+		chainId: '1',
+		collectionAddress: zeroAddress,
+		tokenId: '1',
+		query: {},
+	};
+
+	it('should fetch highest offer data successfully', async () => {
+		const { result } = renderHook(() => useHighestOffer(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({ order: mockOrder });
+		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('GetCollectibleHighestOffer'), () => {
+				return HttpResponse.json(
+					{ error: { message: 'Failed to fetch highest offer' } },
+					{ status: 500 },
+				);
+			}),
+		);
+
+		const { result } = renderHook(() => useHighestOffer(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(() => useHighestOffer(defaultArgs));
+
+		// Wait for initial data
+		await waitFor(() => {
+			expect(result.current.isLoading).toBe(false);
+		});
+
+		// Change args and rerender
+		const newArgs = {
+			...defaultArgs,
+			tokenId: '2',
+			collectionAddress:
+				'0x1234567890123456789012345678901234567890' as `0x${string}`,
+		};
+
+		rerender(() => useHighestOffer(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).toEqual({ order: mockOrder });
+		expect(result.current.isSuccess).toBe(true);
+	});
+
+	it('should handle undefined query params', async () => {
+		const argsWithoutQuery: UseHighestOfferArgs = {
+			chainId: '1',
+			collectionAddress: zeroAddress,
+			tokenId: '1',
+		};
+
+		const { result } = renderHook(() => useHighestOffer(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 = {
+			...defaultArgs,
+			chainId: 'invalid-chain' as string, // Properly typed as string
+		};
+
+		const { result } = renderHook(() => useHighestOffer(invalidArgs));
+
+		await waitFor(() => {
+			expect(result.current.isError).toBe(true);
+		});
+
+		expect(result.current.error).toBeDefined();
+	});
+});

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

@@ -0,0 +1,136 @@
+import { waitFor } from '@testing-library/react';
+import { describe, expect, it, beforeEach } from 'vitest';
+import { useListBalances } from '../useListBalances';
+import { mockTokenBalance } from '../../_internal/api/__mocks__/indexer.msw';
+import { zeroAddress } from 'viem';
+import { server } from '../../_internal/test/setup';
+import { renderHook } from '../../_internal/test-utils';
+
+describe('useListBalances', () => {
+	beforeEach(() => {
+		server.resetHandlers();
+	});
+
+	it('should fetch token balances successfully', async () => {
+		const { result } = renderHook(() =>
+			useListBalances({
+				chainId: 1,
+				accountAddress: zeroAddress,
+				query: {
+					enabled: true,
+				},
+			}),
+		);
+
+		await waitFor(() => {
+			expect(result.current.isSuccess).toBe(true);
+		});
+
+		expect(result.current.data?.pages[0].balances).toEqual([mockTokenBalance]);
+	});
+
+	it('should handle pagination correctly', async () => {
+		const { result } = renderHook(() =>
+			useListBalances({
+				chainId: 1,
+				accountAddress: zeroAddress,
+				query: {
+					enabled: true,
+				},
+				page: {
+					pageSize: 10,
+				},
+			}),
+		);
+
+		await waitFor(() => {
+			expect(result.current.isSuccess).toBe(true);
+		});
+
+		expect(result.current.data?.pages[0].page).toEqual({
+			page: 1,
+			pageSize: 10,
+			more: false,
+		});
+	});
+
+	it('should handle optional parameters', async () => {
+		const { result } = renderHook(() =>
+			useListBalances({
+				chainId: 1,
+				accountAddress: zeroAddress,
+				contractAddress: zeroAddress,
+				tokenId: '1',
+				includeMetadata: true,
+				includeCollectionTokens: true,
+				query: {
+					enabled: true,
+				},
+			}),
+		);
+
+		await waitFor(() => {
+			expect(result.current.isSuccess).toBe(true);
+		});
+
+		const balance = result.current.data?.pages[0].balances[0];
+		expect(balance?.contractInfo).toBeDefined();
+		expect(balance?.tokenMetadata).toBeDefined();
+	});
+
+	it('should handle disabled queries', async () => {
+		const { result } = renderHook(() =>
+			useListBalances({
+				chainId: 1,
+				accountAddress: zeroAddress,
+				query: {
+					enabled: false,
+				},
+			}),
+		);
+
+		expect(result.current.isLoading).toBe(false);
+		expect(result.current.data).toBeUndefined();
+	});
+
+	it('should handle metadata options', async () => {
+		const { result } = renderHook(() =>
+			useListBalances({
+				chainId: 1,
+				accountAddress: zeroAddress,
+				metadataOptions: {
+					verifiedOnly: true,
+					includeContracts: [zeroAddress],
+				},
+				query: {
+					enabled: true,
+				},
+			}),
+		);
+
+		await waitFor(() => {
+			expect(result.current.isSuccess).toBe(true);
+		});
+
+		const balance = result.current.data?.pages[0].balances[0];
+		expect(balance?.contractInfo?.extensions.verified).toBe(true);
+	});
+
+	it('should validate input parameters', async () => {
+		const invalidChainId = 'invalid' as number | string;
+
+		const { result } = renderHook(() =>
+			useListBalances({
+				chainId: invalidChainId,
+				accountAddress: zeroAddress,
+				query: {
+					enabled: true,
+				},
+			}),
+		);
+
+		await waitFor(() => {
+			expect(result.current.isError).toBe(true);
+		});
+	});
+});

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

@@ -0,0 +1,200 @@
+import { describe, expect, it, beforeEach } from 'vitest';
+import { useListCollectibleActivities } from '../useListCollectibleActivities';
+import { renderHook, waitFor } from '../../_internal/test-utils';
+import { zeroAddress } from 'viem';
+import type { UseListCollectibleActivitiesArgs } from '../useListCollectibleActivities';
+import { http, HttpResponse } from 'msw';
+import {
+	mockActivity,
+	mockMarketplaceEndpoint,
+} from '../../_internal/api/__mocks__/marketplace.msw';
+import { server } from '../../_internal/test/setup';
+
+describe('useListCollectibleActivities', () => {
+	const defaultArgs: UseListCollectibleActivitiesArgs = {
+		chainId: '1',
+		collectionAddress: zeroAddress,
+		tokenId: '1',
+		query: {
+			enabled: true,
+			page: 1,
+			pageSize: 10,
+		},
+	};
+
+	// Reset handlers before each test
+	beforeEach(() => {
+		server.resetHandlers();
+	});
+
+	it('should fetch collectible activities successfully', async () => {
+		// Set up the default success handler
+		server.use(
+			http.post(mockMarketplaceEndpoint('ListCollectibleActivities'), () => {
+				return HttpResponse.json({
+					activities: [mockActivity],
+					page: { page: 1, pageSize: 10, more: false },
+				});
+			}),
+		);
+
+		const { result } = renderHook(() =>
+			useListCollectibleActivities(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({
+			activities: [mockActivity],
+			page: { page: 1, pageSize: 10, more: false },
+		});
+		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('ListCollectibleActivities'), () => {
+				return HttpResponse.json(
+					{ error: { message: 'Failed to fetch activities' } },
+					{ status: 500 },
+				);
+			}),
+		);
+
+		const { result } = renderHook(() =>
+			useListCollectibleActivities(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 () => {
+		// Set up the success handler
+		server.use(
+			http.post(mockMarketplaceEndpoint('ListCollectibleActivities'), () => {
+				return HttpResponse.json({
+					activities: [mockActivity],
+					page: { page: 1, pageSize: 10, more: false },
+				});
+			}),
+		);
+
+		let currentArgs = defaultArgs;
+		const { result, rerender } = renderHook(() =>
+			useListCollectibleActivities(currentArgs),
+		);
+
+		// Wait for initial data
+		await waitFor(() => {
+			expect(result.current.isLoading).toBe(false);
+		});
+
+		// Change args and rerender
+		currentArgs = {
+			chainId: '1',
+			tokenId: '2',
+			collectionAddress:
+				'0x1234567890123456789012345678901234567890' as `0x${string}`,
+			query: {
+				enabled: true,
+				page: 1,
+				pageSize: 10,
+			},
+		};
+
+		rerender();
+
+		// 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 disabled queries', async () => {
+		// Set up a mock handler to ensure no requests are made
+		let requestMade = false;
+		server.use(
+			http.post(mockMarketplaceEndpoint('ListCollectibleActivities'), () => {
+				requestMade = true;
+				return HttpResponse.json({
+					activities: [mockActivity],
+					page: { page: 1, pageSize: 10, more: false },
+				});
+			}),
+		);
+
+		// Create a disabled query args
+		const disabledArgs: UseListCollectibleActivitiesArgs = {
+			...defaultArgs,
+			query: {
+				enabled: false,
+				page: 1,
+				pageSize: 10,
+			},
+		};
+
+		// Render hook with disabled query
+		const { result } = renderHook(() =>
+			useListCollectibleActivities(disabledArgs),
+		);
+
+		// 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();
+		expect(requestMade).toBe(false);
+	});
+
+	it('should handle pagination correctly', async () => {
+		// Override the handler for this test to return paginated data
+		server.use(
+			http.post(mockMarketplaceEndpoint('ListCollectibleActivities'), () => {
+				return HttpResponse.json({
+					activities: [mockActivity],
+					page: { page: 2, pageSize: 20, more: false },
+				});
+			}),
+		);
+
+		const paginatedArgs: UseListCollectibleActivitiesArgs = {
+			...defaultArgs,
+			query: {
+				enabled: true,
+				page: 2,
+				pageSize: 20,
+			},
+		};
+
+		const { result } = renderHook(() =>
+			useListCollectibleActivities(paginatedArgs),
+		);
+
+		await waitFor(() => {
+			expect(result.current.isLoading).toBe(false);
+		});
+
+		expect(result.current.data?.page).toEqual({
+			page: 2,
+			pageSize: 20,
+			more: false,
+		});
+	});
+});