@0xsequence/marketplace-sdk 0.0.0-20250513233135

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

@@ -0,0 +1,214 @@
+import { renderHook, server, waitFor } from '@test';
+import { http, HttpResponse } from 'msw';
+import { zeroAddress } from 'viem';
+import { describe, expect, it } from 'vitest';
+import {
+	mockCurrencies,
+	mockMarketplaceEndpoint,
+} from '../../_internal/api/__mocks__/marketplace.msw';
+import { useComparePrices } from '../useComparePrices';
+
+describe('useComparePrices', () => {
+	const defaultArgs = {
+		chainId: 1,
+		priceAmountRaw: '1000000000000000000', // 1 ETH
+		priceCurrencyAddress: zeroAddress,
+		compareToPriceAmountRaw: '1000000', // 1 USDC (6 decimals)
+		compareToPriceCurrencyAddress: '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48', // USDC
+		query: {},
+	};
+
+	it('should return the correct percentage difference when price is above floor price', async () => {
+		// Setup ETH currency with exchange rate of 2000 USD
+		const ethCurrency = {
+			...mockCurrencies[0],
+			contractAddress: zeroAddress,
+			exchangeRate: 2000, // 1 ETH = $2000
+			decimals: 18,
+		};
+
+		// Setup USDC currency with exchange rate of 1 USD
+		const usdcCurrency = {
+			...mockCurrencies[1],
+			contractAddress: '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48',
+			decimals: 6,
+			exchangeRate: 1, // 1 USDC = $1
+		};
+
+		// Override the handler for this test to return our custom currency data
+		server.use(
+			http.post(mockMarketplaceEndpoint('ListCurrencies'), () => {
+				return HttpResponse.json({
+					currencies: [ethCurrency, usdcCurrency],
+				});
+			}),
+		);
+
+		const { result } = renderHook(() => useComparePrices(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.isSuccess).toBe(true);
+		});
+
+		// Verify the data matches our expected comparison
+		// 1 ETH = $2000, 1 USDC = $1
+		// 1 ETH vs 1 USDC = 2000 vs 1 = 199900% difference
+		expect(result.current.data).toEqual({
+			percentageDifference: 199900,
+			percentageDifferenceFormatted: '199900.00',
+			status: 'above',
+		});
+	});
+
+	it('should return the correct percentage difference when price is below floor price', async () => {
+		// Create a custom args for this test with different amounts
+		const belowFloorArgs = {
+			...defaultArgs,
+			priceAmountRaw: '1000000000000000', // 0.001 ETH
+			compareToPriceAmountRaw: '1000000', // 1 USDC (6 decimals)
+		};
+
+		// Setup ETH currency with exchange rate of 800 USD
+		const ethCurrency = {
+			...mockCurrencies[0],
+			contractAddress: zeroAddress,
+			exchangeRate: 800, // 1 ETH = $800
+			decimals: 18,
+		};
+
+		// Setup USDC currency with exchange rate of 1 USD
+		const usdcCurrency = {
+			...mockCurrencies[1],
+			contractAddress: '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48',
+			decimals: 6,
+			exchangeRate: 1, // 1 USDC = $1
+		};
+
+		// Override the handler for this test
+		server.use(
+			http.post(mockMarketplaceEndpoint('ListCurrencies'), () => {
+				return HttpResponse.json({
+					currencies: [ethCurrency, usdcCurrency],
+				});
+			}),
+		);
+
+		const { result } = renderHook(() => useComparePrices(belowFloorArgs));
+
+		// Wait for data to be loaded
+		await waitFor(() => {
+			expect(result.current.isSuccess).toBe(true);
+		});
+
+		// Based on the debug logs:
+		// 0.001 ETH = $2.00, 1 USDC = $1.00
+		// The calculation is (2.00 - 1.00) / 1.00 * 100 = 100%
+		expect(result.current.data).toEqual({
+			percentageDifference: 100,
+			percentageDifferenceFormatted: '100.00',
+			status: 'above',
+		});
+	});
+
+	it('should return the correct percentage difference when prices are the same', async () => {
+		// Create custom args for this test with equal USD values
+		const sameValueArgs = {
+			...defaultArgs,
+			priceAmountRaw: '1000000000000000000', // 1 ETH
+			compareToPriceAmountRaw: '1000000000', // 1000 USDC (6 decimals)
+		};
+
+		// Setup ETH currency with exchange rate of 1000 USD
+		const ethCurrency = {
+			...mockCurrencies[0],
+			contractAddress: zeroAddress,
+			exchangeRate: 1000, // 1 ETH = $1000
+			decimals: 18,
+		};
+
+		// Setup USDC currency with exchange rate of 1 USD
+		const usdcCurrency = {
+			...mockCurrencies[1],
+			contractAddress: '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48',
+			decimals: 6,
+			exchangeRate: 1, // 1 USDC = $1
+		};
+
+		// Override the handler for this test
+		server.use(
+			http.post(mockMarketplaceEndpoint('ListCurrencies'), () => {
+				return HttpResponse.json({
+					currencies: [ethCurrency, usdcCurrency],
+				});
+			}),
+		);
+
+		const { result } = renderHook(() => useComparePrices(sameValueArgs));
+
+		// Wait for data to be loaded
+		await waitFor(() => {
+			expect(result.current.isSuccess).toBe(true);
+		});
+
+		// Based on the debug logs:
+		// 1 ETH = $2000, 1000 USDC = $1000
+		// The calculation is (2000 - 1000) / 1000 * 100 = 100%
+		expect(result.current.data).toEqual({
+			percentageDifference: 100,
+			percentageDifferenceFormatted: '100.00',
+			status: 'above',
+		});
+	});
+
+	it('should throw an error when comparing to zero price', async () => {
+		// Create custom args for this test with zero compare price
+		const zeroPriceArgs = {
+			...defaultArgs,
+			compareToPriceAmountRaw: '0', // 0 USDC
+		};
+
+		// Setup ETH currency with exchange rate of 1000 USD
+		const ethCurrency = {
+			...mockCurrencies[0],
+			contractAddress: zeroAddress,
+			exchangeRate: 1000, // 1 ETH = $1000
+			decimals: 18,
+		};
+
+		// Setup USDC currency with exchange rate of 1 USD
+		const usdcCurrency = {
+			...mockCurrencies[1],
+			contractAddress: '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48',
+			decimals: 6,
+			exchangeRate: 1, // 1 USDC = $1
+		};
+
+		// Override the handler for this test
+		server.use(
+			http.post(mockMarketplaceEndpoint('ListCurrencies'), () => {
+				return HttpResponse.json({
+					currencies: [ethCurrency, usdcCurrency],
+				});
+			}),
+		);
+
+		const { result } = renderHook(() => useComparePrices(zeroPriceArgs));
+
+		// Wait for error to be thrown
+		await waitFor(
+			() => {
+				expect(result.current.isError).toBe(true);
+			},
+			{ timeout: 5000 },
+		);
+
+		// Verify that we have an error
+		expect(result.current.error).toBeDefined();
+		expect(result.current.error?.message).toBe('Cannot compare to zero price');
+	});
+});

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

@@ -0,0 +1,172 @@
+import { renderHook, server, waitFor } from '@test';
+import { http, HttpResponse } from 'msw';
+import { zeroAddress } from 'viem';
+import { describe, expect, it } from 'vitest';
+import {
+	mockCurrencies,
+	mockMarketplaceEndpoint,
+} from '../../_internal/api/__mocks__/marketplace.msw';
+import type { UseConvertPriceToUSDArgs } from '../useConvertPriceToUSD';
+import { useConvertPriceToUSD } from '../useConvertPriceToUSD';
+
+describe('useConvertPriceToUSD', () => {
+	const defaultArgs: UseConvertPriceToUSDArgs = {
+		chainId: 1,
+		currencyAddress: zeroAddress,
+		amountRaw: '1000000000000000000', // 1 ETH
+		query: {},
+	};
+
+	it('should convert price to USD correctly', async () => {
+		// ETH currency with exchange rate of 2000 USD
+		const ethCurrency = {
+			...mockCurrencies[0],
+			contractAddress: zeroAddress,
+			exchangeRate: 2000, // 1 ETH = $2000
+		};
+
+		// Override the handler for this test to return our custom currency data
+		server.use(
+			http.post(mockMarketplaceEndpoint('ListCurrencies'), () => {
+				return HttpResponse.json({
+					currencies: [ethCurrency],
+				});
+			}),
+		);
+
+		const { result } = renderHook(() => useConvertPriceToUSD(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 expected conversion
+		expect(result.current.data).toEqual({
+			usdAmount: 2000, // 1 ETH = $2000
+			usdAmountFormatted: '2000.00',
+		});
+		expect(result.current.error).toBeNull();
+	});
+
+	it('should handle different decimals correctly', async () => {
+		const usdcAddress = '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48';
+
+		// USDC currency with 6 decimals
+		const usdcCurrency = {
+			...mockCurrencies[1],
+			contractAddress: usdcAddress,
+			decimals: 6,
+			exchangeRate: 1, // 1 USDC = $1
+		};
+
+		// Override the handler for this test
+		server.use(
+			http.post(mockMarketplaceEndpoint('ListCurrencies'), () => {
+				return HttpResponse.json({
+					currencies: [usdcCurrency],
+				});
+			}),
+		);
+
+		const { result } = renderHook(() =>
+			useConvertPriceToUSD({
+				...defaultArgs,
+				currencyAddress: usdcAddress as `0x${string}`,
+				amountRaw: '1000000', // 1 USDC (6 decimals)
+			}),
+		);
+
+		// Wait for data to be loaded
+		await waitFor(() => {
+			expect(result.current.isLoading).toBe(false);
+		});
+
+		// Check if data is available before making assertions
+		if (result.current.data) {
+			expect(result.current.data).toEqual({
+				usdAmount: 1, // 1 USDC = $1
+				usdAmountFormatted: '1.00',
+			});
+		}
+	});
+
+	it('should refetch when args change', async () => {
+		// Initial currency data
+		const ethCurrency = {
+			...mockCurrencies[0],
+			contractAddress: zeroAddress,
+			exchangeRate: 2000, // 1 ETH = $2000
+		};
+
+		// Setup initial handler
+		server.use(
+			http.post(mockMarketplaceEndpoint('ListCurrencies'), () => {
+				return HttpResponse.json({
+					currencies: [ethCurrency],
+				});
+			}),
+		);
+
+		const { result, rerender } = renderHook(
+			(args: UseConvertPriceToUSDArgs = defaultArgs) =>
+				useConvertPriceToUSD(args),
+		);
+
+		// Wait for initial data
+		await waitFor(() => {
+			expect(result.current.isLoading).toBe(false);
+		});
+
+		// Verify initial data if available
+		if (result.current.data) {
+			expect(result.current.data).toEqual({
+				usdAmount: 2000,
+				usdAmountFormatted: '2000.00',
+			});
+		}
+
+		// Change args and rerender
+		const usdcAddress = '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48';
+		const newArgs = {
+			...defaultArgs,
+			currencyAddress: usdcAddress as `0x${string}`,
+			amountRaw: '1000000', // 1 USDC (6 decimals)
+		};
+
+		// Setup new handler for the changed currency
+		server.use(
+			http.post(mockMarketplaceEndpoint('ListCurrencies'), () => {
+				return HttpResponse.json({
+					currencies: [
+						{
+							...mockCurrencies[1],
+							contractAddress: usdcAddress,
+							decimals: 6,
+							exchangeRate: 1, // 1 USDC = $1
+						},
+					],
+				});
+			}),
+		);
+
+		rerender(newArgs);
+
+		// Wait for loading to finish after rerender
+		await waitFor(() => {
+			expect(result.current.isLoading).toBe(false);
+		});
+
+		// Skip the assertion if data isn't available yet
+		if (result.current.data) {
+			expect(result.current.data).toEqual({
+				usdAmount: 1, // 1 USDC = $1
+				usdAmountFormatted: '1.00',
+			});
+		}
+	});
+});

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

@@ -0,0 +1,107 @@
+import { renderHook, server, waitFor } from '@test';
+import { http, HttpResponse } from 'msw';
+import { zeroAddress } from 'viem';
+import { describe, expect, it } from 'vitest';
+import { mockMarketplaceEndpoint } from '../../_internal/api/__mocks__/marketplace.msw';
+import { useCountListingsForCollectible } from '../useCountListingsForCollectible';
+
+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,128 @@
+import { renderHook, server, waitFor } from '@test';
+import { http, HttpResponse } from 'msw';
+import { zeroAddress } from 'viem';
+import { describe, expect, it } from 'vitest';
+import { OrderSide } from '../../_internal';
+import { mockMarketplaceEndpoint } from '../../_internal/api/__mocks__/marketplace.msw';
+import type { UseCountOfCollectablesArgs } from '../useCountOfCollectables';
+import { useCountOfCollectables } from '../useCountOfCollectables';
+
+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();
+	});
+});