@0xsequence/marketplace-sdk 1.2.1 → 2.0.0

package/src/react/hooks/{utils/useCheckoutOptionsSalesContract.test.tsx → checkout/primary-sale-checkout-options.test.tsx}

@@ -1,15 +1,15 @@
+import type { Address } from '@0xsequence/api-client';
+import * as MarketplaceMocks from '@0xsequence/api-client/mocks/marketplace';
 import { skipToken } from '@tanstack/react-query';
 import { renderHook, server, waitFor } from '@test';
 import { HttpResponse, http } from 'msw';
-import type { Address } from 'viem';
 import { zeroAddress } from 'viem';
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 import { useAccount } from 'wagmi';
-import {
-	mockCheckoutOptions,
-	mockMarketplaceEndpoint,
-} from '../../_internal/api/__mocks__/marketplace.msw';
-import { useCheckoutOptionsSalesContract } from './useCheckoutOptionsSalesContract';
+
+const { mockCheckoutOptions, mockMarketplaceEndpoint } = MarketplaceMocks;
+
+import { usePrimarySaleCheckoutOptions } from './primary-sale-checkout-options';
 
 // Mock wagmi useAccount hook
 vi.mock('wagmi', async () => {
@@ -27,7 +27,7 @@ const mockContractAddress =
 const mockCollectionAddress =
 	'0xabcdefabcdefabcdefabcdefabcdefabcdefabcd' as Address;
 
-describe('useCheckoutOptionsSalesContract', () => {
+describe('usePrimarySaleCheckoutOptions', () => {
 	beforeEach(() => {
 		vi.clearAllMocks();
 		mockUseAccount.mockReturnValue({
@@ -41,14 +41,14 @@ describe('useCheckoutOptionsSalesContract', () => {
 
 	it('should fetch checkout options successfully', async () => {
 		const { result } = renderHook(() =>
-			useCheckoutOptionsSalesContract({
+			usePrimarySaleCheckoutOptions({
 				chainId: 1,
 				contractAddress: mockContractAddress,
 				collectionAddress: mockCollectionAddress,
 				items: [
 					{
-						quantity: '1',
-						tokenId: '1',
+						quantity: 1n,
+						tokenId: 1n,
 					},
 				],
 			}),
@@ -69,7 +69,7 @@ describe('useCheckoutOptionsSalesContract', () => {
 
 	it('should handle skipToken', () => {
 		const { result } = renderHook(() =>
-			useCheckoutOptionsSalesContract(skipToken),
+			usePrimarySaleCheckoutOptions(skipToken),
 		);
 
 		// Should not be loading when skipToken is passed
@@ -80,18 +80,18 @@ describe('useCheckoutOptionsSalesContract', () => {
 
 	it('should handle multiple items', async () => {
 		const { result } = renderHook(() =>
-			useCheckoutOptionsSalesContract({
+			usePrimarySaleCheckoutOptions({
 				chainId: 137,
 				contractAddress: mockContractAddress,
 				collectionAddress: mockCollectionAddress,
 				items: [
 					{
-						quantity: '2',
-						tokenId: '1',
+						quantity: 2n,
+						tokenId: 1n,
 					},
 					{
-						quantity: '1',
-						tokenId: '2',
+						quantity: 1n,
+						tokenId: 2n,
 					},
 				],
 			}),
@@ -106,10 +106,10 @@ describe('useCheckoutOptionsSalesContract', () => {
 
 	it('should refetch when args change', async () => {
 		let chainIdProp = 1;
-		const itemsProp = [{ quantity: '1', tokenId: '1' }];
+		const itemsProp = [{ quantity: 1n, tokenId: 1n }];
 
 		const { result, rerender } = renderHook(() =>
-			useCheckoutOptionsSalesContract({
+			usePrimarySaleCheckoutOptions({
 				chainId: chainIdProp,
 				contractAddress: mockContractAddress,
 				collectionAddress: mockCollectionAddress,
@@ -151,11 +151,11 @@ describe('useCheckoutOptionsSalesContract', () => {
 		);
 
 		const { result } = renderHook(() =>
-			useCheckoutOptionsSalesContract({
+			usePrimarySaleCheckoutOptions({
 				chainId: 1,
 				contractAddress: mockContractAddress,
 				collectionAddress: mockCollectionAddress,
-				items: [{ quantity: '1', tokenId: '1' }],
+				items: [{ quantity: 1n, tokenId: 1n }],
 			}),
 		);
 
@@ -174,11 +174,11 @@ describe('useCheckoutOptionsSalesContract', () => {
 		} as unknown as ReturnType<typeof useAccount>);
 
 		const { result } = renderHook(() =>
-			useCheckoutOptionsSalesContract({
+			usePrimarySaleCheckoutOptions({
 				chainId: 1,
 				contractAddress: mockContractAddress,
 				collectionAddress: mockCollectionAddress,
-				items: [{ quantity: '1', tokenId: '1' }],
+				items: [{ quantity: 1n, tokenId: 1n }],
 			}),
 		);
 
@@ -190,7 +190,7 @@ describe('useCheckoutOptionsSalesContract', () => {
 
 	it('should handle empty items array', async () => {
 		const { result } = renderHook(() =>
-			useCheckoutOptionsSalesContract({
+			usePrimarySaleCheckoutOptions({
 				chainId: 1,
 				contractAddress: mockContractAddress,
 				collectionAddress: mockCollectionAddress,

package/src/react/hooks/{utils/useCheckoutOptionsSalesContract.tsx → checkout/primary-sale-checkout-options.tsx}

@@ -1,31 +1,37 @@
 'use client';
 
 import { skipToken, useQuery } from '@tanstack/react-query';
-import type { Address } from 'viem';
+import { zeroAddress } from 'viem';
 import { useAccount } from 'wagmi';
-import type { CheckoutOptionsItem, Optional } from '../../_internal';
+import type {
+	CheckoutOptionsItem,
+	HookParamsFromApiRequest,
+} from '../../_internal';
 import {
-	type CheckoutOptionsSalesContractQueryOptions,
-	checkoutOptionsSalesContractQueryOptions,
-	type FetchCheckoutOptionsSalesContractParams,
-	type fetchCheckoutOptionsSalesContract,
-} from '../../queries/market/checkoutOptionsSalesContract';
+	type FetchPrimarySaleCheckoutOptionsParams,
+	type fetchPrimarySaleCheckoutOptions,
+	type PrimarySaleCheckoutOptionsQueryOptions,
+	primarySaleCheckoutOptionsQueryOptions,
+} from '../../queries/checkout/primary-sale-checkout-options';
 import { useConfig } from '../config/useConfig';
 
-export type UseCheckoutOptionsSalesContractParams = Optional<
-	CheckoutOptionsSalesContractQueryOptions,
-	'config' | 'walletAddress'
+export type UsePrimarySaleCheckoutOptionsParams = Omit<
+	HookParamsFromApiRequest<
+		FetchPrimarySaleCheckoutOptionsParams,
+		Pick<PrimarySaleCheckoutOptionsQueryOptions, 'query' | 'config'>
+	>,
+	'walletAddress'
 >;
 
 /**
- * Hook to fetch checkout options for sales contract items
+ * Hook to fetch checkout options for primary sale contract items
  *
  * Retrieves checkout options including available payment methods, fees, and transaction details
- * for items from a sales contract. Requires a connected wallet to calculate wallet-specific options.
+ * for items from a primary sales contract. Requires a connected wallet to calculate wallet-specific options.
  *
  * @param params - Configuration parameters or skipToken to skip the query
  * @param params.chainId - The chain ID (must be number, e.g., 1 for Ethereum, 137 for Polygon)
- * @param params.contractAddress - The sales contract address
+ * @param params.contractAddress - The primary sales contract address
  * @param params.collectionAddress - The collection contract address
  * @param params.items - Array of items to purchase with tokenId and quantity
  * @param params.query - Optional React Query configuration
@@ -35,7 +41,7 @@ export type UseCheckoutOptionsSalesContractParams = Optional<
  * @example
  * Basic usage:
  * ```typescript
- * const { data: checkoutOptions, isLoading } = useCheckoutOptionsSalesContract({
+ * const { data: checkoutOptions, isLoading } = usePrimarySaleCheckoutOptions({
  *   chainId: 137,
  *   contractAddress: '0x1234...',
  *   collectionAddress: '0x5678...',
@@ -49,7 +55,7 @@ export type UseCheckoutOptionsSalesContractParams = Optional<
  * @example
  * With skipToken to conditionally skip:
  * ```typescript
- * const { data: checkoutOptions } = useCheckoutOptionsSalesContract(
+ * const { data: checkoutOptions } = usePrimarySaleCheckoutOptions(
  *   items.length > 0 ? {
  *     chainId: 1,
  *     contractAddress: contractAddress,
@@ -59,27 +65,27 @@ export type UseCheckoutOptionsSalesContractParams = Optional<
  * )
  * ```
  */
-export function useCheckoutOptionsSalesContract(
-	params: UseCheckoutOptionsSalesContractParams | typeof skipToken,
+export function usePrimarySaleCheckoutOptions(
+	params: UsePrimarySaleCheckoutOptionsParams | typeof skipToken,
 ) {
 	const { address } = useAccount();
 	const defaultConfig = useConfig();
 
-	const queryOptions = checkoutOptionsSalesContractQueryOptions(
-		params === skipToken
+	const queryOptions = primarySaleCheckoutOptionsQueryOptions(
+		params === skipToken || !address
 			? {
 					config: defaultConfig,
-					walletAddress: address as Address,
+					walletAddress: address ?? zeroAddress,
 					chainId: 0,
-					contractAddress: '',
-					collectionAddress: '',
+					contractAddress: zeroAddress,
+					collectionAddress: zeroAddress,
 					items: [],
 					query: { enabled: false },
 				}
 			: {
-					config: defaultConfig,
-					walletAddress: address as Address,
 					...params,
+					config: params.config ?? defaultConfig,
+					walletAddress: address,
 				},
 	);
 
@@ -88,21 +94,18 @@ export function useCheckoutOptionsSalesContract(
 	});
 }
 
-export { checkoutOptionsSalesContractQueryOptions };
+export { primarySaleCheckoutOptionsQueryOptions };
 
-export type {
-	FetchCheckoutOptionsSalesContractParams,
-	CheckoutOptionsSalesContractQueryOptions,
-};
+export type { FetchPrimarySaleCheckoutOptionsParams };
 
 // Legacy exports for backward compatibility
-export type UseCheckoutOptionsSalesContractArgs = {
+export type UsePrimarySaleCheckoutOptionsArgs = {
 	chainId: number;
 	contractAddress: string;
 	collectionAddress: string;
 	items: Array<CheckoutOptionsItem>;
 };
 
-export type UseCheckoutOptionsSalesContractReturn = Awaited<
-	ReturnType<typeof fetchCheckoutOptionsSalesContract>
+export type UsePrimarySaleCheckoutOptionsReturn = Awaited<
+	ReturnType<typeof fetchPrimarySaleCheckoutOptions>
 >;

package/src/react/hooks/{data/collectibles/useBalanceOfCollectible.test.tsx → collectible/balance.test.tsx}

@@ -1,17 +1,18 @@
+import * as IndexerMocks from '@0xsequence/api-client/mocks/indexer';
 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 { useBalanceOfCollectible } from './useBalanceOfCollectible';
 
-describe('useBalanceOfCollectible', () => {
+const { mockIndexerEndpoint, mockTokenBalance, mockTokenBalanceNormalized } =
+	IndexerMocks;
+
+import { useCollectibleBalance } from './balance';
+
+describe('useCollectibleBalance', () => {
 	const defaultArgs = {
 		collectionAddress: zeroAddress,
-		collectableId: '1',
+		tokenId: 1n,
 		userAddress: '0x1234567890123456789012345678901234567890' as `0x${string}`,
 		chainId: 1,
 	};
@@ -27,7 +28,7 @@ describe('useBalanceOfCollectible', () => {
 			}),
 		);
 
-		const { result } = renderHook(() => useBalanceOfCollectible(defaultArgs));
+		const { result } = renderHook(() => useCollectibleBalance(defaultArgs));
 
 		// Initially loading
 		expect(result.current.isLoading).toBe(true);
@@ -37,13 +38,13 @@ describe('useBalanceOfCollectible', () => {
 			expect(result.current.isSuccess).toBe(true);
 		});
 
-		// Check the returned data matches mock
-		expect(result.current.data).toEqual(mockTokenBalance);
+		// Check the returned data matches mock (normalized with BigInt)
+		expect(result.current.data).toEqual(mockTokenBalanceNormalized);
 	});
 
 	it('should return null when userAddress is undefined', () => {
 		const { result } = renderHook(() =>
-			useBalanceOfCollectible({
+			useCollectibleBalance({
 				...defaultArgs,
 				userAddress: undefined,
 			}),
@@ -55,7 +56,7 @@ describe('useBalanceOfCollectible', () => {
 
 	it('should respect enabled option in query config', () => {
 		const { result } = renderHook(() =>
-			useBalanceOfCollectible({
+			useCollectibleBalance({
 				...defaultArgs,
 				query: {
 					enabled: false,
@@ -78,15 +79,12 @@ describe('useBalanceOfCollectible', () => {
 			}),
 		);
 
-		const invalidArgs = {
-			...defaultArgs,
-			collectionAddress: '0xinvalid' as `0x${string}`, // Invalid address format
-		};
-
-		const { result } = renderHook(() => useBalanceOfCollectible(invalidArgs));
+		const { result } = renderHook(() => useCollectibleBalance(defaultArgs));
 
 		await waitFor(() => {
 			expect(result.current.isError).toBe(true);
+			expect(result.current.error).toBeDefined();
+			expect(result.current.data).toBeUndefined();
 		});
 	});
 
@@ -94,45 +92,55 @@ describe('useBalanceOfCollectible', () => {
 		const specificCollectible = {
 			collectionAddress:
 				'0x1234567890123456789012345678901234567890' as `0x${string}`,
-			collectableId: '42',
+			tokenId: 42n,
 			userAddress:
 				'0xabcdef1234567890abcdef1234567890abcdef12' as `0x${string}`,
 			chainId: 1,
 		};
 
-		const specificBalance = {
+		// MSW returns RAW format (strings), which gets transformed to normalized format by the client
+		const specificBalanceRaw = {
 			...mockTokenBalance,
 			contractAddress: specificCollectible.collectionAddress,
 			accountAddress: specificCollectible.userAddress,
-			tokenID: specificCollectible.collectableId,
-			balance: '2', // User owns 2 of this collectible
+			tokenID: '42', // API expects string in response
+			balance: '2', // Raw format uses strings
+		};
+
+		// Expected normalized format (BigInt)
+		const specificBalanceNormalized = {
+			...mockTokenBalanceNormalized,
+			contractAddress: specificCollectible.collectionAddress,
+			accountAddress: specificCollectible.userAddress,
+			tokenId: 42n,
+			balance: 2n,
 		};
 
 		server.use(
 			http.post(mockIndexerEndpoint('GetTokenBalances'), () => {
 				return HttpResponse.json({
 					page: { page: 1, pageSize: 10, more: false },
-					balances: [specificBalance],
+					balances: [specificBalanceRaw],
 				});
 			}),
 		);
 
 		const { result } = renderHook(() =>
-			useBalanceOfCollectible(specificCollectible),
+			useCollectibleBalance(specificCollectible),
 		);
 
 		await waitFor(() => {
 			expect(result.current.isSuccess).toBe(true);
 		});
 
-		// Verify the specific collectible balance
-		expect(result.current.data).toEqual(specificBalance);
-		expect(result.current.data?.balance).toBe('2');
+		// Verify the specific collectible balance (normalized format with BigInt)
+		expect(result.current.data).toEqual(specificBalanceNormalized);
+		expect(result.current.data?.balance).toBe(2n);
 		expect(result.current.data?.contractAddress).toBe(
 			specificCollectible.collectionAddress,
 		);
-		expect(result.current.data?.tokenID).toBe(
-			specificCollectible.collectableId,
+		expect(result.current.data?.tokenId).toBe(
+			BigInt(specificCollectible.tokenId),
 		);
 		expect(result.current.data?.accountAddress).toBe(
 			specificCollectible.userAddress,

package/src/react/hooks/{data/collectibles/useBalanceOfCollectible.tsx → collectible/balance.tsx}

@@ -1,9 +1,9 @@
 import { useQuery } from '@tanstack/react-query';
 import {
+	type BalanceOfCollectibleQueryOptions,
 	balanceOfCollectibleOptions,
-	type UseBalanceOfCollectibleArgs,
-} from '../../../queries/collectibles/balanceOfCollectible';
-import { useConfig } from '../../config/useConfig';
+} from '../../queries/collectible/balance';
+import { useConfig } from '../config/useConfig';
 
 /**
  * Hook to fetch the balance of a specific collectible for a user
@@ -13,9 +13,9 @@ import { useConfig } from '../../config/useConfig';
  *
  * @example
  * ```tsx
- * const { data, isLoading, error } = useBalanceOfCollectible({
+ * const { data, isLoading, error } = useCollectibleBalance({
  *   collectionAddress: '0x123...',
- *   collectableId: '1',
+ *   tokenId: 1n,
  *   userAddress: '0x456...',
  *   chainId: 1,
  *   query: {
@@ -25,15 +25,15 @@ import { useConfig } from '../../config/useConfig';
  * });
  * ```
  */
-export function useBalanceOfCollectible(args: UseBalanceOfCollectibleArgs) {
+export function useCollectibleBalance(
+	args: Omit<BalanceOfCollectibleQueryOptions, 'config'>,
+) {
 	const config = useConfig();
 
 	return useQuery(
-		balanceOfCollectibleOptions(
-			{
-				...args,
-			},
+		balanceOfCollectibleOptions({
+			...args,
 			config,
-		),
+		}),
 	);
 }

package/src/react/hooks/{data/primary-sales/useErc721SalesData.tsx → collectible/erc721-sale-details.tsx}

@@ -1,28 +1,28 @@
-import type { Address } from 'viem';
+import type { Address } from '@0xsequence/api-client';
+import { ContractType } from '@0xsequence/api-client';
 import { useReadContract } from 'wagmi';
 import {
 	ERC721_ABI,
 	ERC721_SALE_ABI_V0,
 	ERC721_SALE_ABI_V1,
-} from '../../../../utils';
-import { ContractType } from '../../../_internal';
+} from '../../../utils';
 import {
 	SalesContractVersion,
 	useSalesContractABI,
-} from '../../contracts/useSalesContractABI';
+} from '../contracts/useSalesContractABI';
 
 interface UseErc721CollectionDataProps {
 	chainId: number;
 	salesContractAddress: Address;
 	itemsContractAddress: Address;
-	enabled: boolean;
+	enabled?: boolean;
 }
 
 export function useErc721SaleDetails({
 	chainId,
 	salesContractAddress,
 	itemsContractAddress,
-	enabled,
+	enabled = true,
 }: UseErc721CollectionDataProps) {
 	const {
 		version,

package/src/react/hooks/collectible/index.ts

@@ -0,0 +1,16 @@
+export * from './balance';
+export * from './erc721-sale-details';
+export * from './market-count';
+export * from './market-highest-offer';
+export * from './market-list';
+export * from './market-list-paginated';
+export * from './market-listings';
+export * from './market-listings-count';
+export * from './market-lowest-listing';
+export * from './market-offers';
+export * from './market-offers-count';
+export * from './metadata';
+export * from './primary-sale-item';
+export * from './primary-sale-items';
+export * from './primary-sale-items-count';
+export * from './token-balances';

package/src/react/hooks/{data/collectibles/useCountOfCollectables.test.tsx → collectible/market-count.test.tsx}

@@ -1,20 +1,24 @@
+import type { Address } 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 { mockMarketplaceEndpoint } from '../../../_internal/api/__mocks__/marketplace.msw';
-import { OrderSide } from '../../../_internal/api/marketplace.gen';
-import type { UseCountOfCollectablesParams } from './useCountOfCollectables';
-import { useCountOfCollectables } from './useCountOfCollectables';
 
-describe('useCountOfCollectables', () => {
-	const defaultArgs: UseCountOfCollectablesParams = {
+const { mockMarketplaceEndpoint } = MarketplaceMocks;
+
+import { OrderSide } from '@0xsequence/api-client';
+import type { UseCollectibleMarketCountParams } from './market-count';
+import { useCollectibleMarketCount } from './market-count';
+
+describe('useCollectibleMarketCount', () => {
+	const defaultArgs: UseCollectibleMarketCountParams = {
 		chainId: 1,
 		collectionAddress: zeroAddress,
 		query: {},
 	};
 
-	const defaultArgsWithFilter: UseCountOfCollectablesParams = {
+	const defaultArgsWithFilter: UseCollectibleMarketCountParams = {
 		...defaultArgs,
 		filter: {
 			includeEmpty: true,
@@ -23,7 +27,7 @@ describe('useCountOfCollectables', () => {
 	};
 
 	it('should fetch count of all collectables successfully', async () => {
-		const { result } = renderHook(() => useCountOfCollectables(defaultArgs));
+		const { result } = renderHook(() => useCollectibleMarketCount(defaultArgs));
 
 		// Initially loading
 		expect(result.current.isLoading).toBe(true);
@@ -41,7 +45,7 @@ describe('useCountOfCollectables', () => {
 
 	it('should fetch filtered count of collectables successfully', async () => {
 		const { result } = renderHook(() =>
-			useCountOfCollectables(defaultArgsWithFilter),
+			useCollectibleMarketCount(defaultArgsWithFilter),
 		);
 
 		// Initially loading
@@ -69,7 +73,7 @@ describe('useCountOfCollectables', () => {
 			}),
 		);
 
-		const { result } = renderHook(() => useCountOfCollectables(defaultArgs));
+		const { result } = renderHook(() => useCollectibleMarketCount(defaultArgs));
 
 		await waitFor(() => {
 			expect(result.current.isError).toBe(true);
@@ -81,7 +85,7 @@ describe('useCountOfCollectables', () => {
 
 	it('should refetch when args change', async () => {
 		const { result, rerender } = renderHook(() =>
-			useCountOfCollectables(defaultArgs),
+			useCollectibleMarketCount(defaultArgs),
 		);
 
 		// Wait for initial data
@@ -89,14 +93,15 @@ describe('useCountOfCollectables', () => {
 			expect(result.current.isLoading).toBe(false);
 		});
 
+		const testAddress: Address = '0x1234567890123456789012345678901234567890';
+
 		// Change args and rerender
 		const newArgs = {
 			...defaultArgs,
-			collectionAddress:
-				'0x1234567890123456789012345678901234567890' as `0x${string}`,
+			collectionAddress: testAddress,
 		};
 
-		rerender(() => useCountOfCollectables(newArgs));
+		rerender(() => useCollectibleMarketCount(newArgs));
 
 		// Wait for new data
 		await waitFor(() => {
@@ -109,13 +114,13 @@ describe('useCountOfCollectables', () => {
 	});
 
 	it('should handle undefined query params', async () => {
-		const argsWithoutQuery: UseCountOfCollectablesParams = {
+		const argsWithoutQuery: UseCollectibleMarketCountParams = {
 			chainId: 1,
 			collectionAddress: zeroAddress,
 		};
 
 		const { result } = renderHook(() =>
-			useCountOfCollectables(argsWithoutQuery),
+			useCollectibleMarketCount(argsWithoutQuery),
 		);
 
 		await waitFor(() => {

package/src/react/hooks/{data/collectibles/useCountOfCollectables.tsx → collectible/market-count.tsx}

@@ -1,16 +1,19 @@
 'use client';
 
 import { useQuery } from '@tanstack/react-query';
-import type { Optional } from '../../../_internal';
+import type { Optional, WithRequired } from '../../_internal';
 import {
 	type CountOfCollectablesQueryOptions,
 	countOfCollectablesQueryOptions,
 	type FetchCountOfCollectablesParams,
-} from '../../../queries/collectibles/countOfCollectables';
-import { useConfig } from '../../config/useConfig';
+} from '../../queries/collectible/market-count';
+import { useConfig } from '../config/useConfig';
 
-export type UseCountOfCollectablesParams = Optional<
-	CountOfCollectablesQueryOptions,
+export type UseCollectibleMarketCountParams = Optional<
+	WithRequired<
+		CountOfCollectablesQueryOptions,
+		'chainId' | 'collectionAddress'
+	>,
 	'config'
 >;
 
@@ -33,7 +36,7 @@ export type UseCountOfCollectablesParams = Optional<
  * @example
  * Basic usage (count all collectibles):
  * ```typescript
- * const { data: totalCount, isLoading } = useCountOfCollectables({
+ * const { data: totalCount, isLoading } = useCollectibleMarketCount({
  *   chainId: 137,
  *   collectionAddress: '0x...'
  * })
@@ -42,7 +45,7 @@ export type UseCountOfCollectablesParams = Optional<
  * @example
  * With filters (count filtered collectibles):
  * ```typescript
- * const { data: filteredCount } = useCountOfCollectables({
+ * const { data: filteredCount } = useCollectibleMarketCount({
  *   chainId: 137,
  *   collectionAddress: '0x...',
  *   filter: { priceRange: { min: '1000000000000000000' } },
@@ -50,7 +53,9 @@ export type UseCountOfCollectablesParams = Optional<
  * })
  * ```
  */
-export function useCountOfCollectables(params: UseCountOfCollectablesParams) {
+export function useCollectibleMarketCount(
+	params: UseCollectibleMarketCountParams,
+) {
 	const defaultConfig = useConfig();
 
 	const { config = defaultConfig, ...rest } = params;