@0xsequence/marketplace-sdk 1.2.1 → 2.0.1

package/src/react/hooks/collectible/primary-sale-items-count.tsx

@@ -0,0 +1,22 @@
+import { useQuery } from '@tanstack/react-query';
+import type { Optional } from '../../_internal';
+import type { ListPrimarySaleItemsQueryOptions } from '../../queries/collectible/primary-sale-items';
+import { primarySaleItemsCountQueryOptions } from '../../queries/collectible/primary-sale-items-count';
+import { useConfig } from '../config/useConfig';
+
+export type UsePrimarySaleItemsCountParams = Optional<
+	ListPrimarySaleItemsQueryOptions,
+	'config'
+>;
+
+export function usePrimarySaleItemsCount(args: UsePrimarySaleItemsCountParams) {
+	const defaultConfig = useConfig();
+	const { config = defaultConfig, ...rest } = args;
+
+	const queryOptions = primarySaleItemsCountQueryOptions({
+		config,
+		...rest,
+	});
+
+	return useQuery(queryOptions);
+}

package/src/react/hooks/collectible/primary-sale-items.test.tsx

@@ -0,0 +1,259 @@
+import type { Address } from '@0xsequence/api-client';
+import {
+	type CollectiblePrimarySaleItem,
+	type ListPrimarySaleItemsResponse,
+	Marketplace,
+	type MarketplaceTokenMetadata,
+	MetadataStatus,
+	type PrimarySaleItem,
+} from '@0xsequence/api-client';
+import * as MarketplaceMocks from '@0xsequence/api-client/mocks/marketplace';
+import { renderHook, server, waitFor } from '@test';
+import { HttpResponse, http } from 'msw';
+import { zeroAddress } from 'viem';
+import { describe, expect, it } from 'vitest';
+import { usePrimarySaleItems } from './primary-sale-items';
+
+const { mockMarketplaceEndpoint } = MarketplaceMocks;
+
+const mockTokenMetadata: MarketplaceTokenMetadata = {
+	tokenId: 1n,
+	name: 'Mock NFT',
+	description: 'A mock NFT for testing',
+	image: 'https://example.com/nft.png',
+	attributes: [{ trait_type: 'Type', value: 'Mock' }],
+	status: MetadataStatus.AVAILABLE,
+};
+
+const createMockPrimarySaleItem = (
+	overrides?: Partial<PrimarySaleItem>,
+): PrimarySaleItem => ({
+	itemAddress: '0x1234567890123456789012345678901234567890' as Address,
+	contractType: Marketplace.ContractType.ERC721,
+	tokenId: 1n,
+	itemType: 'global' as any,
+	startDate: new Date('2024-01-01T00:00:00Z').toISOString(),
+	endDate: new Date('2024-12-31T23:59:59Z').toISOString(),
+	currencyAddress: zeroAddress,
+	priceDecimals: 18,
+	priceAmount: 1000000000000000000n, // 1 ETH
+	priceAmountFormatted: '1.0',
+	priceUsd: 1800.0,
+	priceUsdFormatted: '1800.0',
+	supply: 50n,
+	supplyCap: 100n,
+	unlimitedSupply: false,
+	createdAt: new Date().toISOString(),
+	updatedAt: new Date().toISOString(),
+	...overrides,
+});
+
+const createMockCollectiblePrimarySaleItem = (
+	overrides?: Partial<PrimarySaleItem>,
+	metadataOverrides?: Partial<MarketplaceTokenMetadata>,
+): CollectiblePrimarySaleItem => ({
+	metadata: {
+		...mockTokenMetadata,
+		...metadataOverrides,
+	},
+	primarySaleItem: createMockPrimarySaleItem(overrides),
+});
+
+describe('usePrimarySaleItems', () => {
+	const defaultParams = {
+		chainId: 1,
+		primarySaleContractAddress:
+			'0x1234567890123456789012345678901234567890' as Address,
+	};
+
+	it('should fetch primary sale items successfully', async () => {
+		const mockItems = [
+			createMockCollectiblePrimarySaleItem({ tokenId: 1n }),
+			createMockCollectiblePrimarySaleItem({ tokenId: 2n }),
+		];
+
+		const mockResponse: ListPrimarySaleItemsResponse = {
+			primarySaleItems: mockItems,
+			page: {
+				page: 1,
+				pageSize: 10,
+				more: false,
+			},
+		};
+
+		server.use(
+			http.post(mockMarketplaceEndpoint('ListPrimarySaleItems'), () =>
+				HttpResponse.json(mockResponse),
+			),
+		);
+
+		const { result } = renderHook(() => usePrimarySaleItems(defaultParams));
+
+		// Initially loading
+		expect(result.current.isLoading).toBe(true);
+
+		// Wait for data
+		await waitFor(() => {
+			expect(result.current.isLoading).toBe(false);
+		});
+
+		expect(result.current.data).toBeDefined();
+		expect(result.current.data?.pages[0].primarySaleItems).toHaveLength(2);
+		expect(
+			result.current.data?.pages[0].primarySaleItems[0].primarySaleItem.tokenId,
+		).toBe(1n);
+		expect(
+			result.current.data?.pages[0].primarySaleItems[1].primarySaleItem.tokenId,
+		).toBe(2n);
+	});
+
+	it('should handle pagination', async () => {
+		const page1Items = [createMockCollectiblePrimarySaleItem({ tokenId: 1n })];
+		const page2Items = [createMockCollectiblePrimarySaleItem({ tokenId: 2n })];
+
+		server.use(
+			http.post(
+				mockMarketplaceEndpoint('ListPrimarySaleItems'),
+				async ({ request }) => {
+					const body = (await request.json()) as any;
+					const page = body.page?.page || 1;
+
+					if (page === 1) {
+						return HttpResponse.json({
+							primarySaleItems: page1Items,
+							page: {
+								page: 1,
+								pageSize: 1,
+								more: true,
+							},
+						});
+					}
+
+					return HttpResponse.json({
+						primarySaleItems: page2Items,
+						page: {
+							page: 2,
+							pageSize: 1,
+							more: false,
+						},
+					});
+				},
+			),
+		);
+
+		const { result } = renderHook(() =>
+			usePrimarySaleItems({
+				...defaultParams,
+				page: { page: 1, pageSize: 1 },
+			}),
+		);
+
+		await waitFor(() => {
+			expect(result.current.isLoading).toBe(false);
+		});
+
+		expect(result.current.data?.pages).toHaveLength(1);
+		expect(result.current.data?.pages[0].primarySaleItems).toHaveLength(1);
+		expect(result.current.hasNextPage).toBe(true);
+
+		// Fetch next page
+		await result.current.fetchNextPage();
+
+		await waitFor(() => {
+			expect(result.current.data?.pages).toHaveLength(2);
+		});
+
+		expect(result.current.data?.pages[1].primarySaleItems).toHaveLength(1);
+		expect(
+			result.current.data?.pages[1].primarySaleItems[0].primarySaleItem.tokenId,
+		).toBe(2n);
+		expect(result.current.hasNextPage).toBe(false);
+	});
+
+	it('should pass filter parameters to the API', async () => {
+		const mockItems = [createMockCollectiblePrimarySaleItem()];
+		let observedFilter: any;
+
+		server.use(
+			http.post(
+				mockMarketplaceEndpoint('ListPrimarySaleItems'),
+				async ({ request }) => {
+					const body = (await request.json()) as any;
+					observedFilter = body.filter;
+					return HttpResponse.json({
+						primarySaleItems: mockItems,
+						page: { page: 1, pageSize: 10, more: false },
+					});
+				},
+			),
+		);
+
+		const filter = {
+			status: 'active',
+		};
+
+		const { result } = renderHook(() =>
+			usePrimarySaleItems({
+				...defaultParams,
+				filter: filter as any, // Cast if needed depending on exact type match
+			}),
+		);
+
+		await waitFor(() => {
+			expect(result.current.isLoading).toBe(false);
+		});
+
+		expect(observedFilter).toEqual(filter);
+	});
+
+	it('should handle error states', async () => {
+		server.use(
+			http.post(mockMarketplaceEndpoint('ListPrimarySaleItems'), () =>
+				HttpResponse.json(
+					{ error: { message: 'Failed to fetch items' } },
+					{ status: 500 },
+				),
+			),
+		);
+
+		const { result } = renderHook(() => usePrimarySaleItems(defaultParams));
+
+		await waitFor(() => {
+			expect(result.current.isError).toBe(true);
+		});
+
+		expect(result.current.error).toBeDefined();
+	});
+
+	it('should respect enabled option', async () => {
+		const { result } = renderHook(() =>
+			usePrimarySaleItems({
+				...defaultParams,
+				query: { enabled: false },
+			}),
+		);
+
+		expect(result.current.isLoading).toBe(false);
+		expect(result.current.isFetching).toBe(false);
+		expect(result.current.data).toBeUndefined();
+	});
+
+	it('should handle empty results', async () => {
+		server.use(
+			http.post(mockMarketplaceEndpoint('ListPrimarySaleItems'), () =>
+				HttpResponse.json({
+					primarySaleItems: [],
+					page: { page: 1, pageSize: 10, more: false },
+				}),
+			),
+		);
+
+		const { result } = renderHook(() => usePrimarySaleItems(defaultParams));
+
+		await waitFor(() => {
+			expect(result.current.isLoading).toBe(false);
+		});
+
+		expect(result.current.data?.pages[0].primarySaleItems).toHaveLength(0);
+	});
+});

package/src/react/hooks/{data/primary-sales/useListPrimarySaleItems.tsx → collectible/primary-sale-items.tsx}

@@ -1,14 +1,14 @@
 'use client';
 
 import { useInfiniteQuery } from '@tanstack/react-query';
-import type { Optional } from '../../../_internal';
+import type { Optional } from '../../_internal';
 import {
 	type ListPrimarySaleItemsQueryOptions,
-	listPrimarySaleItemsQueryOptions,
-} from '../../../queries/primary-sales/primarySaleItems';
-import { useConfig } from '../../config/useConfig';
+	primarySaleItemsQueryOptions,
+} from '../../queries/collectible/primary-sale-items';
+import { useConfig } from '../config/useConfig';
 
-export type UseListPrimarySaleItemsParams = Optional<
+export type UsePrimarySaleItemsParams = Optional<
 	ListPrimarySaleItemsQueryOptions,
 	'config'
 >;
@@ -31,7 +31,7 @@ export type UseListPrimarySaleItemsParams = Optional<
  * @example
  * Basic usage:
  * ```typescript
- * const { data, isLoading } = useListPrimarySaleItems({
+ * const { data, isLoading } = usePrimarySaleItems({
  *   chainId: 137,
  *   primarySaleContractAddress: '0x...',
  * })
@@ -40,7 +40,7 @@ export type UseListPrimarySaleItemsParams = Optional<
  * @example
  * With filters and pagination:
  * ```typescript
- * const { data, isLoading } = useListPrimarySaleItems({
+ * const { data, isLoading } = usePrimarySaleItems({
  *   chainId: 1,
  *   primarySaleContractAddress: '0x...',
  *   filter: { status: 'active' },
@@ -51,11 +51,11 @@ export type UseListPrimarySaleItemsParams = Optional<
  * })
  * ```
  */
-export function useListPrimarySaleItems(params: UseListPrimarySaleItemsParams) {
+export function usePrimarySaleItems(params: UsePrimarySaleItemsParams) {
 	const defaultConfig = useConfig();
 	const { config = defaultConfig, ...rest } = params;
 
-	const queryOptions = listPrimarySaleItemsQueryOptions({
+	const queryOptions = primarySaleItemsQueryOptions({
 		config,
 		...rest,
 	});

package/src/react/hooks/{data/collectibles/useTokenBalances.test.tsx → collectible/token-balances.test.tsx}

@@ -1,14 +1,15 @@
+import * as IndexerMocks from '@0xsequence/api-client/mocks/indexer';
+
+const { mockIndexerEndpoint, mockTokenBalance, mockTokenBalanceNormalized } =
+	IndexerMocks;
+
 import { renderHook, server, waitFor } from '@test';
 import { HttpResponse, http } from 'msw';
 import { zeroAddress } from 'viem';
 import { describe, expect, it } from 'vitest';
-import {
-	mockIndexerEndpoint,
-	mockTokenBalance,
-} from '../../../_internal/api/__mocks__/indexer.msw';
-import { useTokenBalances } from './useTokenBalances';
+import { useCollectibleTokenBalances } from './token-balances';
 
-describe('useTokenBalances', () => {
+describe('useCollectibleTokenBalances', () => {
 	const defaultArgs = {
 		collectionAddress: zeroAddress,
 		userAddress: '0x1234567890123456789012345678901234567890' as `0x${string}`,
@@ -17,8 +18,9 @@ describe('useTokenBalances', () => {
 
 	it('should fetch balances successfully', async () => {
 		// Override the handler specifically for this test
+		// MSW returns RAW format, which gets transformed to normalized by the client
 		server.use(
-			http.post(mockIndexerEndpoint('GetTokenBalances'), () => {
+			http.post(mockIndexerEndpoint('GetTokenBalancesByContract'), () => {
 				return HttpResponse.json({
 					page: { page: 1, pageSize: 10, more: false },
 					balances: [mockTokenBalance, { ...mockTokenBalance, tokenID: '2' }],
@@ -26,7 +28,9 @@ describe('useTokenBalances', () => {
 			}),
 		);
 
-		const { result } = renderHook(() => useTokenBalances(defaultArgs));
+		const { result } = renderHook(() =>
+			useCollectibleTokenBalances(defaultArgs),
+		);
 
 		// Initially loading
 		expect(result.current.isLoading).toBe(true);
@@ -36,15 +40,15 @@ describe('useTokenBalances', () => {
 			expect(result.current.isSuccess).toBe(true);
 		});
 
-		// Check the returned data matches mock
+		// Check the returned data matches mock (normalized with BigInt)
 		expect(result.current.data).toHaveLength(2);
-		expect(result.current.data?.[0]).toEqual(mockTokenBalance);
-		expect(result.current.data?.[1].tokenID).toBe('2');
+		expect(result.current.data?.[0]).toEqual(mockTokenBalanceNormalized);
+		expect(result.current.data?.[1].tokenId).toBe(2n);
 	});
 
 	it('should return empty array when userAddress is undefined', () => {
 		const { result } = renderHook(() =>
-			useTokenBalances({
+			useCollectibleTokenBalances({
 				...defaultArgs,
 				userAddress: undefined,
 			}),
@@ -56,7 +60,7 @@ describe('useTokenBalances', () => {
 
 	it('should respect enabled option in query config', () => {
 		const { result } = renderHook(() =>
-			useTokenBalances({
+			useCollectibleTokenBalances({
 				...defaultArgs,
 				query: {
 					enabled: false,
@@ -71,7 +75,7 @@ describe('useTokenBalances', () => {
 	it('should handle error states', async () => {
 		// Override the handler to return an error
 		server.use(
-			http.post(mockIndexerEndpoint('GetTokenBalances'), () => {
+			http.post(mockIndexerEndpoint('GetTokenBalancesByContract'), () => {
 				return HttpResponse.json(
 					{ error: { message: 'Invalid address format' } },
 					{ status: 400 },
@@ -79,15 +83,14 @@ describe('useTokenBalances', () => {
 			}),
 		);
 
-		const invalidArgs = {
-			...defaultArgs,
-			collectionAddress: '0xinvalid' as `0x${string}`, // Invalid address format
-		};
-
-		const { result } = renderHook(() => useTokenBalances(invalidArgs));
+		const { result } = renderHook(() =>
+			useCollectibleTokenBalances(defaultArgs),
+		);
 
 		await waitFor(() => {
 			expect(result.current.isError).toBe(true);
+			expect(result.current.error).toBeDefined();
+			expect(result.current.data).toBeUndefined();
 		});
 	});
 
@@ -100,7 +103,8 @@ describe('useTokenBalances', () => {
 			chainId: 1,
 		};
 
-		const balances = [
+		// MSW returns RAW format (strings)
+		const balancesRaw = [
 			{
 				...mockTokenBalance,
 				contractAddress: specificCollection.collectionAddress,
@@ -117,26 +121,46 @@ describe('useTokenBalances', () => {
 			},
 		];
 
+		// Expected normalized format (BigInt)
+		const balancesNormalized = [
+			{
+				...mockTokenBalanceNormalized,
+				contractAddress: specificCollection.collectionAddress,
+				accountAddress: specificCollection.userAddress,
+				tokenId: 1n,
+				balance: 2n,
+			},
+			{
+				...mockTokenBalanceNormalized,
+				contractAddress: specificCollection.collectionAddress,
+				accountAddress: specificCollection.userAddress,
+				tokenId: 2n,
+				balance: 1n,
+			},
+		];
+
 		server.use(
-			http.post(mockIndexerEndpoint('GetTokenBalances'), () => {
+			http.post(mockIndexerEndpoint('GetTokenBalancesByContract'), () => {
 				return HttpResponse.json({
 					page: { page: 1, pageSize: 10, more: false },
-					balances,
+					balances: balancesRaw,
 				});
 			}),
 		);
 
-		const { result } = renderHook(() => useTokenBalances(specificCollection));
+		const { result } = renderHook(() =>
+			useCollectibleTokenBalances(specificCollection),
+		);
 
 		await waitFor(() => {
 			expect(result.current.isSuccess).toBe(true);
 		});
 
-		// Verify all token balances
-		expect(result.current.data).toEqual(balances);
+		// Verify all token balances (normalized format)
+		expect(result.current.data).toEqual(balancesNormalized);
 		expect(result.current.data).toHaveLength(2);
-		expect(result.current.data?.[0].balance).toBe('2');
-		expect(result.current.data?.[1].balance).toBe('1');
+		expect(result.current.data?.[0].balance).toBe(2n);
+		expect(result.current.data?.[1].balance).toBe(1n);
 		expect(
 			result.current.data?.every(
 				(b) => b.contractAddress === specificCollection.collectionAddress,

package/src/react/hooks/{data/collectibles/useTokenBalances.tsx → collectible/token-balances.tsx}

@@ -1,9 +1,9 @@
 import { useQuery } from '@tanstack/react-query';
 import {
+	type TokenBalancesQueryOptions,
 	tokenBalancesOptions,
-	type UseTokenBalancesArgs,
-} from '../../../queries/collectibles/tokenBalances';
-import { useConfig } from '../../config/useConfig';
+} from '../../queries/collectible/token-balances';
+import { useConfig } from '../config/useConfig';
 
 /**
  * Hook to fetch all token balances for a user in a collection
@@ -13,7 +13,7 @@ import { useConfig } from '../../config/useConfig';
  *
  * @example
  * ```tsx
- * const { data, isLoading, error } = useTokenBalances({
+ * const { data, isLoading, error } = useCollectibleTokenBalances({
  *   collectionAddress: '0x123...',
  *   userAddress: '0x456...',
  *   chainId: 1,
@@ -24,15 +24,15 @@ import { useConfig } from '../../config/useConfig';
  * });
  * ```
  */
-export function useTokenBalances(args: UseTokenBalancesArgs) {
+export function useCollectibleTokenBalances(
+	args: Omit<TokenBalancesQueryOptions, 'config'>,
+) {
 	const config = useConfig();
 
 	return useQuery(
-		tokenBalancesOptions(
-			{
-				...args,
-			},
+		tokenBalancesOptions({
+			...args,
 			config,
-		),
+		}),
 	);
 }