@0xsequence/marketplace-sdk 1.1.0 → 1.2.0

package/src/react/hooks/data/inventory/useInventory.tsx

@@ -1,21 +1,12 @@
 import { useQuery } from '@tanstack/react-query';
-import { ContractType } from '../../../_internal';
 import {
 	inventoryOptions,
 	type UseInventoryArgs,
-} from '../../../queries/inventory';
+} from '../../../queries/inventory/inventory';
 import { useConfig } from '../../config/useConfig';
-import { useMarketplaceConfig } from '../../config/useMarketplaceConfig';
 
 export function useInventory(args: UseInventoryArgs) {
 	const config = useConfig();
-	const { data: marketplaceConfig } = useMarketplaceConfig();
 
-	const isLaos721 =
-		marketplaceConfig?.market?.collections?.find(
-			(c) =>
-				c.itemsAddress === args.collectionAddress && c.chainId === args.chainId,
-		)?.contractType === ContractType.LAOS_ERC_721;
-
-	return useQuery(inventoryOptions({ ...args, isLaos721 }, config));
+	return useQuery(inventoryOptions({ ...args }, config));
 }

package/src/react/hooks/data/market/useCurrency.tsx

@@ -6,7 +6,7 @@ import {
 	type CurrencyQueryOptions,
 	currencyQueryOptions,
 	type FetchCurrencyParams,
-} from '../../../queries/currency';
+} from '../../../queries/market/currency';
 import { useConfig } from '../../config/useConfig';
 
 export type UseCurrencyParams = Optional<CurrencyQueryOptions, 'config'>;

package/src/react/hooks/data/market/useListMarketCardData.tsx

@@ -11,6 +11,7 @@ import type {
 	PropertyFilter,
 } from '../../../../types';
 import { OrderSide } from '../../../../types';
+import type { PriceFilter } from '../../../_internal';
 import type { MarketCollectibleCardProps } from '../../../ui/components/marketplace-collectible-card/types';
 import { useSellModal } from '../../../ui/modals/SellModal';
 import { useListCollectibles } from '../collectibles/useListCollectibles';
@@ -25,10 +26,12 @@ interface UseListMarketCardDataProps {
 	filterOptions?: PropertyFilter[];
 	searchText?: string;
 	showListedOnly?: boolean;
+	priceFilters?: PriceFilter[];
 	onCollectibleClick?: (tokenId: string) => void;
 	onCannotPerformAction?: (action: CollectibleCardAction) => void;
 	prioritizeOwnerActions?: boolean;
 	assetSrcPrefixUrl?: string;
+	hideQuantitySelector?: boolean;
 }
 
 export function useListMarketCardData({
@@ -39,10 +42,12 @@ export function useListMarketCardData({
 	filterOptions,
 	searchText,
 	showListedOnly = false,
+	priceFilters,
 	onCollectibleClick,
 	onCannotPerformAction,
 	prioritizeOwnerActions,
 	assetSrcPrefixUrl,
+	hideQuantitySelector,
 }: UseListMarketCardDataProps) {
 	const { address: accountAddress } = useAccount();
 	const { show: showSellModal } = useSellModal();
@@ -63,6 +68,7 @@ export function useListMarketCardData({
 			includeEmpty: !showListedOnly,
 			searchText,
 			properties: filterOptions,
+			prices: priceFilters,
 		},
 		query: {
 			enabled: !!collectionAddress && !!chainId,
@@ -111,6 +117,7 @@ export function useListMarketCardData({
 				onCannotPerformAction,
 				prioritizeOwnerActions,
 				assetSrcPrefixUrl,
+				hideQuantitySelector,
 				onOfferClick: ({ order }) => {
 					if (!accountAddress) return;
 

package/src/react/hooks/data/market/useMarketCurrencies.test.tsx

@@ -49,7 +49,30 @@ describe('useMarketCurrencies', () => {
 		);
 	});
 
-	it('should filter currencies by collection address', async () => {
+	it('should filter currencies by collection address for non-OpenSea collections', async () => {
+		const args = {
+			...defaultArgs,
+			collectionAddress: mockConfig.marketCollections[0]
+				.itemsAddress as Address,
+		} satisfies Parameters<typeof useMarketCurrencies>[0];
+
+		const { result } = renderHook(() => useMarketCurrencies(args));
+
+		await waitFor(() => {
+			expect(result.current.isLoading).toBe(false);
+		});
+
+		const currencyAddresses = result.current.data?.map(
+			(c) => c.contractAddress,
+		);
+
+		// For non-OpenSea collections, currencies should be filtered by currencyOptions
+		expect(currencyAddresses).toEqual(
+			mockConfig.marketCollections[0].currencyOptions,
+		);
+	});
+
+	it('should not filter currencies by collection address for OpenSea collections', async () => {
 		const args = {
 			...defaultArgs,
 			collectionAddress: mockConfig.marketCollections[1]
@@ -65,8 +88,12 @@ describe('useMarketCurrencies', () => {
 		const currencyAddresses = result.current.data?.map(
 			(c) => c.contractAddress,
 		);
+
+		// For OpenSea collections, currencies are not filtered by currencyOptions
+		// Instead, all currencies are returned and filtering happens at the UI level
+		// based on openseaListing/openseaOffer flags
 		expect(currencyAddresses).toEqual(
-			mockConfig.marketCollections[1].currencyOptions,
+			mockCurrencies.map((c) => c.contractAddress),
 		);
 	});
 
@@ -161,6 +188,8 @@ describe('useMarketCurrencies', () => {
 			    "imageUrl": "https://example.com/usdc.png",
 			    "name": "USD Coin",
 			    "nativeCurrency": false,
+			    "openseaListing": true,
+			    "openseaOffer": true,
 			    "status": "active",
 			    "symbol": "USDC",
 			    "updatedAt": "2025-03-16T13:04:16.098Z",

package/src/react/hooks/data/market/useMarketCurrencies.tsx

@@ -6,7 +6,7 @@ import {
 	type FetchMarketCurrenciesParams,
 	type MarketCurrenciesQueryOptions,
 	marketCurrenciesQueryOptions,
-} from '../../../queries/marketCurrencies';
+} from '../../../queries/market/marketCurrencies';
 import { useConfig } from '../../config/useConfig';
 
 export type UseMarketCurrenciesParams = Optional<

package/src/react/hooks/data/orders/index.ts

@@ -1,7 +1,11 @@
+export * from './useCountItemsOrdersForCollection';
 export * from './useCountListingsForCollectible';
 export * from './useCountOffersForCollectible';
 export * from './useFloorOrder';
+export * from './useGetCountOfFilteredOrders';
 export * from './useHighestOffer';
+export * from './useListItemsOrdersForCollection';
+export * from './useListItemsOrdersForCollectionPaginated';
 export * from './useListListingsForCollectible';
 export * from './useListOffersForCollectible';
 export * from './useLowestListing';

package/src/react/hooks/data/orders/useCountItemsOrdersForCollection.tsx

@@ -0,0 +1,90 @@
+'use client';
+
+import { useQuery } from '@tanstack/react-query';
+import type { Optional } from '../../../_internal';
+import {
+	type CountItemsOrdersForCollectionQueryOptions,
+	countItemsOrdersForCollectionQueryOptions,
+	type FetchCountItemsOrdersForCollectionParams,
+} from '../../../queries/orders/countItemsOrdersForCollection';
+import { useConfig } from '../../config/useConfig';
+
+export type UseCountItemsOrdersForCollectionParams = Optional<
+	CountItemsOrdersForCollectionQueryOptions,
+	'config'
+>;
+
+/**
+ * Hook to get the count of orders for a collection
+ *
+ * Counts the total number of active orders (listings) for all tokens
+ * in a collection. Useful for displaying order counts in collection UI.
+ *
+ * @param params - Configuration parameters
+ * @param params.chainId - The chain ID (must be number, e.g., 1 for Ethereum, 137 for Polygon)
+ * @param params.collectionAddress - The collection contract address
+ * @param params.filter - Optional filter criteria for orders
+ * @param params.query - Optional React Query configuration
+ *
+ * @returns Query result containing the count of orders
+ *
+ * @example
+ * Basic usage:
+ * ```typescript
+ * const { data: orderCount, isLoading } = useCountItemsOrdersForCollection({
+ *   chainId: 137,
+ *   collectionAddress: '0x...'
+ * })
+ * ```
+ *
+ * @example
+ * With filter:
+ * ```typescript
+ * const { data: filteredCount } = useCountItemsOrdersForCollection({
+ *   chainId: 137,
+ *   collectionAddress: '0x...',
+ *   filter: {
+ *     marketplace: [MarketplaceKind.sequence_marketplace_v2]
+ *   }
+ * })
+ * ```
+ *
+ * @example
+ * Combined with list hook:
+ * ```typescript
+ * const { data: totalCount } = useCountItemsOrdersForCollection({
+ *   chainId: 137,
+ *   collectionAddress: '0x...'
+ * })
+ *
+ * const { data: orders } = useListItemsOrdersForCollection({
+ *   chainId: 137,
+ *   collectionAddress: '0x...'
+ * })
+ *
+ * return <div>Showing {orders?.pages[0]?.listings.length ?? 0} of {totalCount} orders</div>
+ * ```
+ */
+export function useCountItemsOrdersForCollection(
+	params: UseCountItemsOrdersForCollectionParams,
+) {
+	const defaultConfig = useConfig();
+
+	const { config = defaultConfig, ...rest } = params;
+
+	const queryOptions = countItemsOrdersForCollectionQueryOptions({
+		config,
+		...rest,
+	});
+
+	return useQuery({
+		...queryOptions,
+	});
+}
+
+export { countItemsOrdersForCollectionQueryOptions };
+
+export type {
+	FetchCountItemsOrdersForCollectionParams,
+	CountItemsOrdersForCollectionQueryOptions,
+};

package/src/react/hooks/data/orders/useCountListingsForCollectible.tsx

@@ -6,7 +6,7 @@ import {
 	type CountListingsForCollectibleQueryOptions,
 	countListingsForCollectibleQueryOptions,
 	type FetchCountListingsForCollectibleParams,
-} from '../../../queries/countListingsForCollectible';
+} from '../../../queries/orders/countListingsForCollectible';
 import { useConfig } from '../../config/useConfig';
 
 export type UseCountListingsForCollectibleParams = Optional<

package/src/react/hooks/data/orders/useCountOffersForCollectible.tsx

@@ -6,7 +6,7 @@ import {
 	type CountOffersForCollectibleQueryOptions,
 	countOffersForCollectibleQueryOptions,
 	type FetchCountOffersForCollectibleParams,
-} from '../../../queries/countOffersForCollectible';
+} from '../../../queries/orders/countOffersForCollectible';
 import { useConfig } from '../../config/useConfig';
 
 export type UseCountOffersForCollectibleParams = Optional<

package/src/react/hooks/data/orders/useFloorOrder.tsx

@@ -6,7 +6,7 @@ import {
 	type FetchFloorOrderParams,
 	type FloorOrderQueryOptions,
 	floorOrderQueryOptions,
-} from '../../../queries/floorOrder';
+} from '../../../queries/orders/floorOrder';
 import { useConfig } from '../../config/useConfig';
 
 export type UseFloorOrderParams = Optional<FloorOrderQueryOptions, 'config'>;

package/src/react/hooks/data/orders/useGetCountOfFilteredOrders.tsx

@@ -0,0 +1,39 @@
+'use client';
+
+import { useQuery } from '@tanstack/react-query';
+import type { Optional } from '../../../_internal';
+import {
+	type FetchGetCountOfFilteredOrdersParams,
+	type GetCountOfFilteredOrdersQueryOptions,
+	getCountOfFilteredOrdersQueryOptions,
+} from '../../../queries/orders/getCountOfFilteredOrders';
+import { useConfig } from '../../config/useConfig';
+
+export type UseGetCountOfFilteredOrdersParams = Optional<
+	GetCountOfFilteredOrdersQueryOptions,
+	'config'
+>;
+
+export function useGetCountOfFilteredOrders(
+	params: UseGetCountOfFilteredOrdersParams,
+) {
+	const defaultConfig = useConfig();
+
+	const { config = defaultConfig, ...rest } = params;
+
+	const queryOptions = getCountOfFilteredOrdersQueryOptions({
+		config,
+		...rest,
+	});
+
+	return useQuery({
+		...queryOptions,
+	});
+}
+
+export { getCountOfFilteredOrdersQueryOptions };
+
+export type {
+	FetchGetCountOfFilteredOrdersParams,
+	GetCountOfFilteredOrdersQueryOptions,
+};

package/src/react/hooks/data/orders/useHighestOffer.tsx

@@ -6,7 +6,7 @@ import {
 	type FetchHighestOfferParams,
 	type HighestOfferQueryOptions,
 	highestOfferQueryOptions,
-} from '../../../queries/highestOffer';
+} from '../../../queries/orders/highestOffer';
 import { useConfig } from '../../config/useConfig';
 
 export type UseHighestOfferParams = Optional<

package/src/react/hooks/data/orders/useListItemsOrdersForCollection.tsx

@@ -0,0 +1,93 @@
+'use client';
+
+import { useInfiniteQuery } from '@tanstack/react-query';
+import type { Optional } from '../../../_internal';
+import {
+	type FetchListItemsOrdersForCollectionParams,
+	type fetchListItemsOrdersForCollection,
+	type ListItemsOrdersForCollectionQueryOptions,
+	listItemsOrdersForCollectionQueryOptions,
+} from '../../../queries/orders/listItemsOrdersForCollection';
+import { useConfig } from '../../config/useConfig';
+
+export type UseListItemsOrdersForCollectionParams = Optional<
+	ListItemsOrdersForCollectionQueryOptions,
+	'config'
+>;
+
+/**
+ * Hook to fetch all listings for a collection with infinite pagination support
+ *
+ * Fetches active listings (sales) for all tokens in a collection from the marketplace
+ * with support for filtering and infinite scroll pagination.
+ *
+ * @param params - Configuration parameters
+ * @param params.chainId - The chain ID (must be number, e.g., 1 for Ethereum, 137 for Polygon)
+ * @param params.collectionAddress - The collection contract address
+ * @param params.filter - Optional filtering parameters (marketplace, currencies, etc.)
+ * @param params.query - Optional React Query configuration
+ *
+ * @returns Infinite query result containing listings data with pagination
+ *
+ * @example
+ * Basic usage:
+ * ```typescript
+ * const { data, isLoading, fetchNextPage, hasNextPage } = useListItemsOrdersForCollection({
+ *   chainId: 137,
+ *   collectionAddress: '0x...'
+ * })
+ * ```
+ *
+ * @example
+ * With filtering:
+ * ```typescript
+ * const { data, fetchNextPage } = useListItemsOrdersForCollection({
+ *   chainId: 1,
+ *   collectionAddress: '0x...',
+ *   filter: {
+ *     marketplace: [MarketplaceKind.sequence_marketplace_v2],
+ *     currencies: ['0x...']
+ *   }
+ * })
+ * ```
+ *
+ * @example
+ * Accessing paginated data:
+ * ```typescript
+ * const { data } = useListItemsOrdersForCollection({
+ *   chainId: 137,
+ *   collectionAddress: '0x...'
+ * })
+ *
+ * const allListings = data?.pages.flatMap(page => page.listings) ?? []
+ * ```
+ */
+export function useListItemsOrdersForCollection(
+	params: UseListItemsOrdersForCollectionParams,
+) {
+	const defaultConfig = useConfig();
+
+	const { config = defaultConfig, ...rest } = params;
+
+	const queryOptions = listItemsOrdersForCollectionQueryOptions({
+		config,
+		...rest,
+	});
+
+	return useInfiniteQuery({
+		...queryOptions,
+	});
+}
+
+export { listItemsOrdersForCollectionQueryOptions };
+
+export type {
+	FetchListItemsOrdersForCollectionParams,
+	ListItemsOrdersForCollectionQueryOptions,
+};
+
+export type UseListItemsOrdersForCollectionArgs =
+	UseListItemsOrdersForCollectionParams;
+export type UseListItemsOrdersForCollectionReturn = Awaited<
+	ReturnType<typeof fetchListItemsOrdersForCollection>
+>;

package/src/react/hooks/data/orders/useListItemsOrdersForCollectionPaginated.tsx

@@ -0,0 +1,108 @@
+'use client';
+
+import { useQuery } from '@tanstack/react-query';
+import type { Optional } from '../../../_internal';
+import {
+	type FetchListItemsOrdersForCollectionPaginatedParams,
+	type fetchListItemsOrdersForCollectionPaginated,
+	type ListItemsOrdersForCollectionPaginatedQueryOptions,
+	listItemsOrdersForCollectionPaginatedQueryOptions,
+} from '../../../queries/orders/listItemsOrdersForCollectionPaginated';
+import { useConfig } from '../../config/useConfig';
+
+export type UseListItemsOrdersForCollectionPaginatedParams = Optional<
+	ListItemsOrdersForCollectionPaginatedQueryOptions,
+	'config'
+>;
+
+/**
+ * Hook to fetch all listings for a collection with pagination support
+ *
+ * Fetches active listings (sales) for all tokens in a collection from the marketplace
+ * with support for filtering and pagination. Unlike the infinite query version,
+ * this hook fetches a specific page of results.
+ *
+ * @param params - Configuration parameters
+ * @param params.chainId - The chain ID (must be number, e.g., 1 for Ethereum, 137 for Polygon)
+ * @param params.collectionAddress - The collection contract address
+ * @param params.side - Order side (listing or bid)
+ * @param params.filter - Optional filtering parameters (marketplace, currencies, etc.)
+ * @param params.page - Page number to fetch (default: 1)
+ * @param params.pageSize - Number of items per page (default: 30)
+ * @param params.query - Optional React Query configuration
+ *
+ * @returns Query result containing listings data for the specific page
+ *
+ * @example
+ * Basic usage:
+ * ```typescript
+ * const { data, isLoading } = useListItemsOrdersForCollectionPaginated({
+ *   chainId: 137,
+ *   collectionAddress: '0x...',
+ *   side: OrderSide.listing,
+ *   page: 1,
+ *   pageSize: 20
+ * })
+ * ```
+ *
+ * @example
+ * With filtering:
+ * ```typescript
+ * const { data } = useListItemsOrdersForCollectionPaginated({
+ *   chainId: 1,
+ *   collectionAddress: '0x...',
+ *   side: OrderSide.listing,
+ *   page: 2,
+ *   pageSize: 50,
+ *   filter: {
+ *     marketplace: [MarketplaceKind.sequence_marketplace_v2],
+ *     currencies: ['0x...']
+ *   }
+ * })
+ * ```
+ *
+ * @example
+ * Controlled pagination:
+ * ```typescript
+ * const [currentPage, setCurrentPage] = useState(1);
+ * const { data, isLoading } = useListItemsOrdersForCollectionPaginated({
+ *   chainId: 137,
+ *   collectionAddress: '0x...',
+ *   side: OrderSide.listing,
+ *   page: currentPage,
+ *   pageSize: 25
+ * });
+ *
+ * const hasMorePages = data?.page?.more;
+ * ```
+ */
+export function useListItemsOrdersForCollectionPaginated(
+	params: UseListItemsOrdersForCollectionPaginatedParams,
+) {
+	const defaultConfig = useConfig();
+
+	const { config = defaultConfig, ...rest } = params;
+
+	const queryOptions = listItemsOrdersForCollectionPaginatedQueryOptions({
+		config,
+		...rest,
+	});
+
+	return useQuery({
+		...queryOptions,
+	});
+}
+
+export { listItemsOrdersForCollectionPaginatedQueryOptions };
+
+export type {
+	FetchListItemsOrdersForCollectionPaginatedParams,
+	ListItemsOrdersForCollectionPaginatedQueryOptions,
+};
+
+// Legacy exports for backward compatibility during migration
+export type UseListItemsOrdersForCollectionPaginatedArgs =
+	UseListItemsOrdersForCollectionPaginatedParams;
+export type UseListItemsOrdersForCollectionPaginatedReturn = Awaited<
+	ReturnType<typeof fetchListItemsOrdersForCollectionPaginated>
+>;

package/src/react/hooks/data/orders/useListListingsForCollectible.tsx

@@ -7,7 +7,7 @@ import {
 	type fetchListListingsForCollectible,
 	type ListListingsForCollectibleQueryOptions,
 	listListingsForCollectibleQueryOptions,
-} from '../../../queries/listListingsForCollectible';
+} from '../../../queries/orders/listListingsForCollectible';
 import { useConfig } from '../../config/useConfig';
 
 export type UseListListingsForCollectibleParams = Optional<

package/src/react/hooks/data/orders/useListOffersForCollectible.tsx

@@ -6,7 +6,7 @@ import {
 	type FetchListOffersForCollectibleParams,
 	type ListOffersForCollectibleQueryOptions,
 	listOffersForCollectibleQueryOptions,
-} from '../../../queries/listOffersForCollectible';
+} from '../../../queries/orders/listOffersForCollectible';
 import { useConfig } from '../../config/useConfig';
 
 export type UseListOffersForCollectibleParams = Optional<

package/src/react/hooks/data/orders/useLowestListing.tsx

@@ -6,7 +6,7 @@ import {
 	type FetchLowestListingParams,
 	type LowestListingQueryOptions,
 	lowestListingQueryOptions,
-} from '../../../queries/lowestListing';
+} from '../../../queries/orders/lowestListing';
 import { useConfig } from '../../config/useConfig';
 
 export type UseLowestListingParams = Optional<

package/src/react/hooks/data/primary-sales/index.ts

@@ -4,3 +4,4 @@ export * from './useGetCountOfPrimarySaleItems';
 export * from './useList721ShopCardData';
 export * from './useList1155ShopCardData';
 export * from './useListPrimarySaleItems';
+export * from './usePrimarySaleItem';

package/src/react/hooks/data/primary-sales/useGetCountOfPrimarySaleItems.tsx

@@ -2,8 +2,8 @@
 
 import { useQuery } from '@tanstack/react-query';
 import type { Optional } from '../../../_internal';
-import type { ListPrimarySaleItemsQueryOptions } from '../../../queries/primarySaleItems';
-import { primarySaleItemsCountQueryOptions } from '../../../queries/primarySaleItemsCount';
+import type { ListPrimarySaleItemsQueryOptions } from '../../../queries/primary-sales/primarySaleItems';
+import { primarySaleItemsCountQueryOptions } from '../../../queries/primary-sales/primarySaleItemsCount';
 import { useConfig } from '../../config/useConfig';
 
 export type UseGetCountParams = Optional<

package/src/react/hooks/data/primary-sales/useListPrimarySaleItems.tsx

@@ -5,7 +5,7 @@ import type { Optional } from '../../../_internal';
 import {
 	type ListPrimarySaleItemsQueryOptions,
 	listPrimarySaleItemsQueryOptions,
-} from '../../../queries/primarySaleItems';
+} from '../../../queries/primary-sales/primarySaleItems';
 import { useConfig } from '../../config/useConfig';
 
 export type UseListPrimarySaleItemsParams = Optional<

package/src/react/hooks/data/primary-sales/usePrimarySaleItem.tsx

@@ -0,0 +1,71 @@
+'use client';
+
+import { useQuery } from '@tanstack/react-query';
+import type { Optional } from '../../../_internal';
+import {
+	type FetchPrimarySaleItemParams,
+	type PrimarySaleItemQueryOptions,
+	primarySaleItemQueryOptions,
+} from '../../../queries/primary-sales/primarySaleItem';
+import { useConfig } from '../../config/useConfig';
+
+export type UsePrimarySaleItemParams = Optional<
+	PrimarySaleItemQueryOptions,
+	'config'
+>;
+
+/**
+ * Hook to fetch a single primary sale item
+ *
+ * Retrieves details for a specific primary sale item from a primary sale contract.
+ *
+ * @param params - Configuration parameters
+ * @param params.chainId - The chain ID (must be number, e.g., 1 for Ethereum, 137 for Polygon)
+ * @param params.primarySaleContractAddress - The primary sale contract address
+ * @param params.tokenId - The token ID of the primary sale item
+ * @param params.query - Optional React Query configuration
+ *
+ * @returns Query result containing the primary sale item data
+ *
+ * @example
+ * Basic usage:
+ * ```typescript
+ * const { data: item, isLoading } = usePrimarySaleItem({
+ *   chainId: 137,
+ *   primarySaleContractAddress: '0x...',
+ *   tokenId: '1',
+ * })
+ * ```
+ *
+ * @example
+ * With custom query options:
+ * ```typescript
+ * const { data } = usePrimarySaleItem({
+ *   chainId: 1,
+ *   primarySaleContractAddress: '0x...',
+ *   tokenId: '42',
+ *   query: {
+ *     enabled: Boolean(primarySaleContractAddress && tokenId),
+ *     staleTime: 30_000
+ *   }
+ * })
+ * ```
+ */
+export function usePrimarySaleItem(params: UsePrimarySaleItemParams) {
+	const defaultConfig = useConfig();
+
+	const { config = defaultConfig, ...rest } = params;
+
+	const queryOptions = primarySaleItemQueryOptions({
+		config,
+		...rest,
+	});
+
+	return useQuery({
+		...queryOptions,
+	});
+}
+
+export { primarySaleItemQueryOptions };
+
+export type { FetchPrimarySaleItemParams, PrimarySaleItemQueryOptions };