@0xsequence/marketplace-sdk 0.5.1 → 0.5.3

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

@@ -0,0 +1,111 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { useCurrencyBalance } from '../useCurrencyBalance';
+import { renderHook, waitFor } from '../../_internal/test-utils';
+import { zeroAddress } from 'viem';
+import {
+	createMockPublicClient,
+	commonPublicClientMocks,
+} from '../../_internal/test/mocks/publicClient';
+import { getPublicRpcClient } from '../../../utils/get-public-rpc-client';
+
+// Mock the getPublicRpcClient function
+vi.mock('../../../utils/get-public-rpc-client', () => ({
+	getPublicRpcClient: vi.fn(() => createMockPublicClient()),
+}));
+
+describe('useCurrencyBalance', () => {
+	const defaultArgs = {
+		chainId: 1,
+		userAddress: '0x1234567890123456789012345678901234567890' as `0x${string}`,
+		currencyAddress: zeroAddress,
+	};
+
+	beforeEach(() => {
+		vi.clearAllMocks();
+	});
+
+	it('should fetch native token balance successfully', async () => {
+		const { result } = renderHook(() => useCurrencyBalance(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({
+			value: BigInt('1000000000000000000'),
+			formatted: '1',
+		});
+		expect(result.current.error).toBeNull();
+		expect(commonPublicClientMocks.getBalance).toHaveBeenCalledWith({
+			address: defaultArgs.userAddress,
+		});
+	});
+
+	it('should fetch ERC20 token balance successfully', async () => {
+		const erc20Args = {
+			...defaultArgs,
+			currencyAddress:
+				'0x1234567890123456789012345678901234567890' as `0x${string}`,
+		};
+
+		const { result } = renderHook(() => useCurrencyBalance(erc20Args));
+
+		// 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({
+			value: BigInt('1000000000000000000'),
+			formatted: '1',
+		});
+		expect(result.current.error).toBeNull();
+		expect(commonPublicClientMocks.readContract).toHaveBeenCalledTimes(2);
+	});
+
+	it('should return skipToken when required parameters are missing', () => {
+		const { result } = renderHook(() =>
+			useCurrencyBalance({
+				chainId: undefined,
+				userAddress: undefined,
+				currencyAddress: undefined,
+			}),
+		);
+
+		expect(result.current.data).toBeUndefined();
+		expect(result.current.isLoading).toBe(false);
+		expect(commonPublicClientMocks.getBalance).not.toHaveBeenCalled();
+		expect(commonPublicClientMocks.readContract).not.toHaveBeenCalled();
+	});
+
+	it('should handle errors from public client', async () => {
+		// Mock error response
+		const mockError = new Error('Failed to fetch balance');
+		const mockPublicClient = createMockPublicClient({
+			getBalance: vi.fn().mockRejectedValue(mockError),
+		});
+
+		// Override the mock for this test
+		vi.mocked(getPublicRpcClient).mockReturnValue(mockPublicClient);
+
+		const { result } = renderHook(() => useCurrencyBalance(defaultArgs));
+
+		await waitFor(() => {
+			expect(result.current.isError).toBe(true);
+		});
+
+		expect(result.current.error).toBeDefined();
+		expect(result.current.data).toBeUndefined();
+	});
+});

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

@@ -0,0 +1,127 @@
+import { describe, expect, it } from 'vitest';
+import { useFilters } from '../useFilters';
+import { renderHook, waitFor } from '../../_internal/test-utils';
+import { zeroAddress } from 'viem';
+import type { UseFiltersArgs } from '../useFilters';
+import { http, HttpResponse } from 'msw';
+import { mockMetadataEndpoint } from '../../_internal/api/__mocks__/metadata.msw';
+import { server } from '../../_internal/test/setup';
+
+describe('useFilters', () => {
+	const defaultArgs: UseFiltersArgs = {
+		chainId: '1',
+		collectionAddress: zeroAddress,
+	};
+
+	it('should fetch filters successfully', async () => {
+		const { result } = renderHook(() => useFilters(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.error).toBeNull();
+	});
+
+	it('should handle error states', async () => {
+		// Override the handler for this test to return an error
+		server.use(
+			http.post(mockMetadataEndpoint('TokenCollectionFilters'), () => {
+				return HttpResponse.json(
+					{ error: { message: 'Failed to fetch filters' } },
+					{ status: 500 },
+				);
+			}),
+		);
+
+		const { result } = renderHook(() => useFilters(defaultArgs));
+
+		await waitFor(() => {
+			expect(result.current.isError).toBe(true);
+		});
+
+		expect(result.current.error).toBeDefined();
+		expect(result.current.data).toBeUndefined();
+	});
+
+	it('should apply different filter exclusion rules', async () => {
+		const { result } = renderHook(() => useFilters(defaultArgs));
+
+		await waitFor(() => {
+			expect(result.current.isSuccess).toBe(true);
+		});
+
+		// Verify that:
+		// 1. "Sample" is excluded from Type filter
+		// 2. Rarity filter is unchanged
+		// 3. Filters are in the correct order
+		expect(result.current.data).toMatchInlineSnapshot(`
+			[
+			  {
+			    "name": "Type",
+			    "type": "STRING",
+			    "values": [
+			      "Mock",
+			      "Test",
+			    ],
+			  },
+			  {
+			    "name": "Rarity",
+			    "type": "STRING",
+			    "values": [
+			      "Common",
+			      "Uncommon",
+			      "Rare",
+			      "Epic",
+			      "Legendary",
+			    ],
+			  },
+			]
+		`);
+	});
+
+	it('should validate input parameters', async () => {
+		const invalidArgs: UseFiltersArgs = {
+			...defaultArgs,
+			// @ts-expect-error
+			chainId: {}, // Using an object instead of a string/number will fail validation
+		};
+
+		const { result } = renderHook(() => useFilters(invalidArgs));
+
+		await waitFor(() => {
+			expect(result.current.isError).toBe(true);
+		});
+
+		expect(result.current.error).toBeDefined();
+	});
+
+	it('should return filter values in correct format', async () => {
+		const { result } = renderHook(() => useFilters(defaultArgs));
+
+		await waitFor(() => {
+			expect(result.current.isSuccess).toBe(true);
+		});
+
+		// Verify filter structure and processing
+		expect(result.current.data).toEqual(
+			expect.arrayContaining([
+				expect.objectContaining({
+					name: expect.any(String),
+					type: expect.any(String),
+					values: expect.arrayContaining([expect.any(String)]),
+				}),
+			]),
+		);
+
+		// Verify that "Sample" is excluded from Type filter
+		const typeFilter = result.current.data?.find((f) => f.name === 'Type');
+		expect(typeFilter?.values).not.toContain('Sample');
+	});
+});

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

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

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

@@ -0,0 +1,173 @@
+import { describe, expect, it, vi, beforeEach } from 'vitest';
+import { useGenerateBuyTransaction } from '../useGenerateBuyTransaction';
+import { MarketplaceKind, WalletKind } from '../../_internal';
+import { http, HttpResponse } from 'msw';
+import {
+	mockSteps,
+	mockMarketplaceEndpoint,
+} from '../../_internal/api/__mocks__/marketplace.msw';
+import { server } from '../../_internal/test/setup';
+import { renderHook } from '../../_internal/test-utils';
+import { useDisconnect, useConnect, mock, useAccount } from 'wagmi';
+
+describe('useGenerateBuyTransaction', () => {
+	const defaultArgs = {
+		chainId: '1',
+		collectionAddress:
+			'0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266' as `0x${string}`,
+		marketplace: MarketplaceKind.sequence_marketplace_v2,
+		ordersData: [
+			{
+				marketplace: MarketplaceKind.sequence_marketplace_v2,
+				orderId: '1',
+				quantity: '1',
+				price: '1',
+				currency: 'ETH',
+				currencyAddress:
+					'0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266' as `0x${string}`,
+				currencyDecimals: 18,
+				currencySymbol: 'ETH',
+				currencyName: 'Ether',
+			},
+		],
+		walletType: WalletKind.sequence,
+		query: {},
+	};
+
+	beforeEach(() => {
+		vi.clearAllMocks();
+
+		// Mock default steps response with delay to simulate loading state
+		server.use(
+			http.post(mockMarketplaceEndpoint('GenerateBuyTransaction'), async () => {
+				await new Promise((resolve) => setTimeout(resolve, 100)); // Add small delay
+				return HttpResponse.json({
+					steps: mockSteps,
+				});
+			}),
+		);
+	});
+
+	it('should skip query when no address is available', async () => {
+		const { result: generateBuyTransactionResult } = renderHook(() =>
+			useGenerateBuyTransaction(defaultArgs),
+		);
+		const { result: disconnectResult } = renderHook(() => useDisconnect());
+
+		// make sure we are disconnected
+		await disconnectResult.current.disconnectAsync();
+
+		expect(generateBuyTransactionResult.current.isLoading).toBe(false);
+		expect(generateBuyTransactionResult.current.error).toBeNull();
+		expect(generateBuyTransactionResult.current.data).toBeUndefined();
+	});
+
+	it('should fetch transaction data when wallet is connected', async () => {
+		// Setup mock wallet connection
+		const mockAddress = '0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266';
+		const { result: accountResult } = renderHook(() => useAccount());
+		const { result: connectResult } = renderHook(() => useConnect());
+
+		await connectResult.current.connectAsync({
+			connector: mock({
+				accounts: [mockAddress],
+			}),
+		});
+
+		// Ensure we have a connected wallet
+		expect(accountResult.current.address).toBe(mockAddress);
+
+		const { result } = renderHook(() => useGenerateBuyTransaction(defaultArgs));
+
+		// Initial state should be loading
+		expect(result.current.isLoading).toBe(true);
+		expect(result.current.data).toBeUndefined();
+
+		// Wait for the query to complete
+		await vi.waitFor(() => {
+			expect(result.current.isLoading).toBe(false);
+		});
+
+		// Verify the data matches our mock
+		expect(result.current.error).toBeNull();
+		expect(result.current.data).toEqual(mockSteps);
+	});
+
+	it('should handle API errors correctly', async () => {
+		// Setup mock wallet connection
+		const mockAddress = '0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266';
+		const { result: connectResult } = renderHook(() => useConnect());
+
+		await connectResult.current.connectAsync({
+			connector: mock({
+				accounts: [mockAddress],
+			}),
+		});
+
+		// Mock API error response
+		server.use(
+			http.post(mockMarketplaceEndpoint('GenerateBuyTransaction'), () => {
+				return HttpResponse.json(
+					{ message: 'Invalid order data' },
+					{ status: 400 },
+				);
+			}),
+		);
+
+		const { result } = renderHook(() => useGenerateBuyTransaction(defaultArgs));
+
+		// Initial state should be loading
+		expect(result.current.isLoading).toBe(true);
+		expect(result.current.error).toBeNull();
+		expect(result.current.data).toBeUndefined();
+
+		// Wait for the query to complete
+		await vi.waitFor(() => {
+			expect(result.current.isLoading).toBe(false);
+		});
+
+		// Verify error state
+		expect(result.current.error).toBeTruthy();
+		expect(result.current.data).toBeUndefined();
+	});
+
+	it('should handle invalid input arguments correctly', async () => {
+		// Setup mock wallet connection
+		const mockAddress = '0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266';
+		const { result: connectResult } = renderHook(() => useConnect());
+
+		await connectResult.current.connectAsync({
+			connector: mock({
+				accounts: [mockAddress],
+			}),
+		});
+
+		// Create invalid args by omitting required fields and using invalid types
+		const invalidArgs = {
+			...defaultArgs,
+			chainId: 1, // Should be string
+			collectionAddress: 'invalid-address', // Invalid address format
+			ordersData: [
+				{
+					...defaultArgs.ordersData[0],
+					quantity: 1, // Should be string
+					orderId: undefined, // Required field missing
+				},
+			],
+		};
+
+		const { result } = renderHook(() =>
+			// @ts-expect-error - Testing runtime validation
+			useGenerateBuyTransaction(invalidArgs),
+		);
+
+		// Wait for the query to complete
+		await vi.waitFor(() => {
+			expect(result.current.isLoading).toBe(false);
+		});
+
+		// Verify validation error state
+		expect(result.current.error).toBeTruthy();
+		expect(result.current.data).toBeUndefined();
+	});
+});