@0xsequence/marketplace-sdk 0.8.12 → 0.10.0

package/src/react/hooks/useCountListingsForCollectible.tsx

@@ -1,64 +1,75 @@
-import { queryOptions, useQuery } from '@tanstack/react-query';
-import { z } from 'zod';
-import type { SdkConfig } from '../../types';
+'use client';
+
+import { useQuery } from '@tanstack/react-query';
+import type { Optional } from '../_internal';
 import {
-	AddressSchema,
-	QueryArgSchema,
-	collectableKeys,
-	getMarketplaceClient,
-} from '../_internal';
-import { countListingsForCollectibleArgsSchema } from '../_internal/api/zod-schema';
+	type CountListingsForCollectibleQueryOptions,
+	countListingsForCollectibleQueryOptions,
+	type FetchCountListingsForCollectibleParams,
+} from '../queries/countListingsForCollectible';
 import { useConfig } from './useConfig';
 
-const UseCountListingsForCollectibleArgsSchema =
-	countListingsForCollectibleArgsSchema
-		.omit({
-			contractAddress: true,
-			tokenId: true,
-		})
-		.extend({
-			collectionAddress: AddressSchema,
-			collectibleId: z.string(),
-			chainId: z.number(),
-			query: QueryArgSchema,
-		});
-
-export type UseCountListingsForCollectibleArgs = z.infer<
-	typeof UseCountListingsForCollectibleArgsSchema
+export type UseCountListingsForCollectibleParams = Optional<
+	CountListingsForCollectibleQueryOptions,
+	'config'
 >;
 
-export type UseCountListingsForCollectibleReturn = Awaited<
-	ReturnType<typeof fetchCountListingsForCollectible>
->;
+/**
+ * Hook to get the count of listings for a specific collectible
+ *
+ * Counts the number of active listings for a given collectible in the marketplace.
+ * Useful for displaying listing counts in UI components.
+ *
+ * @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.collectibleId - The specific collectible/token ID
+ * @param params.filter - Optional filter criteria for listings
+ * @param params.query - Optional React Query configuration
+ *
+ * @returns Query result containing the count of listings
+ *
+ * @example
+ * Basic usage:
+ * ```typescript
+ * const { data: listingCount, isLoading } = useCountListingsForCollectible({
+ *   chainId: 137,
+ *   collectionAddress: '0x...',
+ *   collectibleId: '123'
+ * })
+ * ```
+ *
+ * @example
+ * With filter:
+ * ```typescript
+ * const { data: filteredCount } = useCountListingsForCollectible({
+ *   chainId: 137,
+ *   collectionAddress: '0x...',
+ *   collectibleId: '123',
+ *   filter: { priceRange: { min: '1000000000000000000' } }
+ * })
+ * ```
+ */
+export function useCountListingsForCollectible(
+	params: UseCountListingsForCollectibleParams,
+) {
+	const defaultConfig = useConfig();
+
+	const { config = defaultConfig, ...rest } = params;
 
-const fetchCountListingsForCollectible = async (
-	args: UseCountListingsForCollectibleArgs,
-	config: SdkConfig,
-) => {
-	const parsedArgs = UseCountListingsForCollectibleArgsSchema.parse(args);
-	const marketplaceClient = getMarketplaceClient(config);
-	const { chainId, collectionAddress, collectibleId } = parsedArgs;
-	return marketplaceClient.getCountOfListingsForCollectible({
-		chainId: String(chainId),
-		contractAddress: collectionAddress,
-		tokenId: collectibleId,
+	const queryOptions = countListingsForCollectibleQueryOptions({
+		config,
+		...rest,
 	});
-};
 
-export const countListingsForCollectibleOptions = (
-	args: UseCountListingsForCollectibleArgs,
-	config: SdkConfig,
-) => {
-	return queryOptions({
-		...args.query,
-		queryKey: [...collectableKeys.listingsCount, args, config],
-		queryFn: () => fetchCountListingsForCollectible(args, config),
+	return useQuery({
+		...queryOptions,
 	});
-};
+}
+
+export { countListingsForCollectibleQueryOptions };
 
-export const useCountListingsForCollectible = (
-	args: UseCountListingsForCollectibleArgs,
-) => {
-	const config = useConfig();
-	return useQuery(countListingsForCollectibleOptions(args, config));
+export type {
+	FetchCountListingsForCollectibleParams,
+	CountListingsForCollectibleQueryOptions,
 };

package/src/react/hooks/useCountOfCollectables.tsx

@@ -1,79 +1,70 @@
-import { queryOptions, useQuery } from '@tanstack/react-query';
-import { z } from 'zod';
-import type { SdkConfig } from '../../types';
+'use client';
+
+import { useQuery } from '@tanstack/react-query';
+import type { Optional } from '../_internal';
 import {
-	AddressSchema,
-	OrderSide,
-	QueryArgSchema,
-	collectableKeys,
-	getMarketplaceClient,
-} from '../_internal';
-import { collectiblesFilterSchema } from '../_internal/api/zod-schema';
+	type CountOfCollectablesQueryOptions,
+	countOfCollectablesQueryOptions,
+	type FetchCountOfCollectablesParams,
+} from '../queries/countOfCollectables';
 import { useConfig } from './useConfig';
 
-const BaseSchema = z.object({
-	chainId: z.number(),
-	collectionAddress: AddressSchema,
-	query: QueryArgSchema,
-});
-
-const UseCountOfCollectableSchema = BaseSchema.extend({
-	filter: collectiblesFilterSchema,
-	side: z.nativeEnum(OrderSide),
-}).or(
-	BaseSchema.extend({
-		filter: z.undefined(),
-		side: z.undefined(),
-	}),
-);
-
-export type UseCountOfCollectablesArgs = z.infer<
-	typeof UseCountOfCollectableSchema
+export type UseCountOfCollectablesParams = Optional<
+	CountOfCollectablesQueryOptions,
+	'config'
 >;
 
-export type UseContOfCollectableReturn = Awaited<
-	ReturnType<typeof fetchCountOfCollectables>
->;
+/**
+ * Hook to get the count of collectibles in a market collection
+ *
+ * Counts either all collectibles or filtered collectibles based on provided parameters.
+ * When filter and side parameters are provided, returns count of filtered collectibles.
+ * Otherwise returns count of all collectibles in the collection.
+ *
+ * @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 collectibles
+ * @param params.side - Optional order side (BUY/SELL) when using filters
+ * @param params.query - Optional React Query configuration
+ *
+ * @returns Query result containing the count of collectibles
+ *
+ * @example
+ * Basic usage (count all collectibles):
+ * ```typescript
+ * const { data: totalCount, isLoading } = useCountOfCollectables({
+ *   chainId: 137,
+ *   collectionAddress: '0x...'
+ * })
+ * ```
+ *
+ * @example
+ * With filters (count filtered collectibles):
+ * ```typescript
+ * const { data: filteredCount } = useCountOfCollectables({
+ *   chainId: 137,
+ *   collectionAddress: '0x...',
+ *   filter: { priceRange: { min: '1000000000000000000' } },
+ *   side: OrderSide.SELL
+ * })
+ * ```
+ */
+export function useCountOfCollectables(params: UseCountOfCollectablesParams) {
+	const defaultConfig = useConfig();
 
-const fetchCountOfCollectables = async (
-	args: UseCountOfCollectablesArgs,
-	config: SdkConfig,
-) => {
-	const parsedArgs = UseCountOfCollectableSchema.parse(args);
-	const marketplaceClient = getMarketplaceClient(config);
-	const { chainId, collectionAddress, filter, side } = parsedArgs;
+	const { config = defaultConfig, ...rest } = params;
 
-	if (filter) {
-		return marketplaceClient
-			.getCountOfFilteredCollectibles({
-				chainId: String(chainId),
-				contractAddress: collectionAddress,
-				filter,
-				// biome-ignore lint/style/noNonNullAssertion: safe to assert here, as it's validated
-				side: side!,
-			})
-			.then((resp) => resp.count);
-	}
-	return marketplaceClient
-		.getCountOfAllCollectibles({
-			chainId: String(chainId),
-			contractAddress: collectionAddress,
-		})
-		.then((resp) => resp.count);
-};
+	const queryOptions = countOfCollectablesQueryOptions({
+		config,
+		...rest,
+	});
 
-export const countOfCollectablesOptions = (
-	args: UseCountOfCollectablesArgs,
-	config: SdkConfig,
-) => {
-	return queryOptions({
-		...args.query,
-		queryKey: [...collectableKeys.counts, args],
-		queryFn: () => fetchCountOfCollectables(args, config),
+	return useQuery({
+		...queryOptions,
 	});
-};
+}
+
+export { countOfCollectablesQueryOptions };
 
-export const useCountOfCollectables = (args: UseCountOfCollectablesArgs) => {
-	const config = useConfig();
-	return useQuery(countOfCollectablesOptions(args, config));
-};
+export type { FetchCountOfCollectablesParams, CountOfCollectablesQueryOptions };

package/src/react/hooks/useCountOfPrimarySaleItems.tsx

@@ -0,0 +1,13 @@
+import { useQuery } from '@tanstack/react-query';
+import {
+	countOfPrimarySaleItemsOptions,
+	type UseCountOfPrimarySaleItemsArgs,
+} from '../queries';
+import { useConfig } from './useConfig';
+
+export function useCountOfPrimarySaleItems(
+	args: UseCountOfPrimarySaleItemsArgs,
+) {
+	const config = useConfig();
+	return useQuery(countOfPrimarySaleItemsOptions(args, config));
+}

package/src/react/hooks/useCountOffersForCollectible.tsx

@@ -1,64 +1,75 @@
-import { queryOptions, useQuery } from '@tanstack/react-query';
-import { z } from 'zod';
-import type { SdkConfig } from '../../types';
+'use client';
+
+import { useQuery } from '@tanstack/react-query';
+import type { Optional } from '../_internal';
 import {
-	AddressSchema,
-	QueryArgSchema,
-	collectableKeys,
-	getMarketplaceClient,
-} from '../_internal';
-import { countOffersForCollectibleArgsSchema } from '../_internal/api/zod-schema';
+	type CountOffersForCollectibleQueryOptions,
+	countOffersForCollectibleQueryOptions,
+	type FetchCountOffersForCollectibleParams,
+} from '../queries/countOffersForCollectible';
 import { useConfig } from './useConfig';
 
-const UseCountOffersForCollectibleArgsSchema =
-	countOffersForCollectibleArgsSchema
-		.omit({
-			contractAddress: true,
-			tokenId: true,
-		})
-		.extend({
-			collectionAddress: AddressSchema,
-			collectibleId: z.string(),
-			chainId: z.number(),
-			query: QueryArgSchema,
-		});
-
-export type UseCountOffersForCollectibleArgs = z.infer<
-	typeof UseCountOffersForCollectibleArgsSchema
+export type UseCountOffersForCollectibleParams = Optional<
+	CountOffersForCollectibleQueryOptions,
+	'config'
 >;
 
-export type UseCountOffersForCollectibleReturn = Awaited<
-	ReturnType<typeof fetchCountOffersForCollectible>
->;
+/**
+ * Hook to get the count of offers for a specific collectible
+ *
+ * Counts the number of active offers for a given collectible in the marketplace.
+ * Useful for displaying offer counts in UI components.
+ *
+ * @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.collectibleId - The specific collectible/token ID
+ * @param params.filter - Optional filter criteria for offers
+ * @param params.query - Optional React Query configuration
+ *
+ * @returns Query result containing the count of offers
+ *
+ * @example
+ * Basic usage:
+ * ```typescript
+ * const { data: offerCount, isLoading } = useCountOffersForCollectible({
+ *   chainId: 137,
+ *   collectionAddress: '0x...',
+ *   collectibleId: '123'
+ * })
+ * ```
+ *
+ * @example
+ * With filter:
+ * ```typescript
+ * const { data: filteredCount } = useCountOffersForCollectible({
+ *   chainId: 137,
+ *   collectionAddress: '0x...',
+ *   collectibleId: '123',
+ *   filter: { priceRange: { min: '1000000000000000000' } }
+ * })
+ * ```
+ */
+export function useCountOffersForCollectible(
+	params: UseCountOffersForCollectibleParams,
+) {
+	const defaultConfig = useConfig();
+
+	const { config = defaultConfig, ...rest } = params;
 
-const fetchCountOffersForCollectible = async (
-	args: UseCountOffersForCollectibleArgs,
-	config: SdkConfig,
-) => {
-	const parsedArgs = UseCountOffersForCollectibleArgsSchema.parse(args);
-	const marketplaceClient = getMarketplaceClient(config);
-	const { chainId, collectionAddress, collectibleId } = parsedArgs;
-	return marketplaceClient.getCountOfOffersForCollectible({
-		chainId: String(chainId),
-		contractAddress: collectionAddress,
-		tokenId: collectibleId,
+	const queryOptions = countOffersForCollectibleQueryOptions({
+		config,
+		...rest,
 	});
-};
 
-export const countOffersForCollectibleOptions = (
-	args: UseCountOffersForCollectibleArgs,
-	config: SdkConfig,
-) => {
-	return queryOptions({
-		...args.query,
-		queryKey: [...collectableKeys.offersCount, args, config],
-		queryFn: () => fetchCountOffersForCollectible(args, config),
+	return useQuery({
+		...queryOptions,
 	});
-};
+}
+
+export { countOffersForCollectibleQueryOptions };
 
-export const useCountOffersForCollectible = (
-	args: UseCountOffersForCollectibleArgs,
-) => {
-	const config = useConfig();
-	return useQuery(countOffersForCollectibleOptions(args, config));
+export type {
+	FetchCountOffersForCollectibleParams,
+	CountOffersForCollectibleQueryOptions,
 };

package/src/react/hooks/useCurrency.tsx

@@ -1,73 +1,65 @@
-import { queryOptions, skipToken, useQuery } from '@tanstack/react-query';
-import { z } from 'zod';
-import type { SdkConfig } from '../../types';
+'use client';
+
+import { useQuery } from '@tanstack/react-query';
+import type { Optional } from '../_internal';
 import {
-	AddressSchema,
-	type Currency,
-	QueryArgSchema,
-	currencyKeys,
-	getMarketplaceClient,
-	getQueryClient,
-} from '../_internal';
+	type CurrencyQueryOptions,
+	currencyQueryOptions,
+	type FetchCurrencyParams,
+} from '../queries/currency';
 import { useConfig } from './useConfig';
 
-const UseCurrencyArgsSchema = z.object({
-	chainId: z.number(),
-	currencyAddress: AddressSchema.optional(),
-	query: QueryArgSchema,
-});
-
-type UseCurrencyArgs = z.input<typeof UseCurrencyArgsSchema>;
-
-export type UseCurrencyReturn = Currency | undefined;
-
-const fetchCurrency = async (
-	chainId: number,
-	currencyAddress: string,
-	config: SdkConfig,
-): Promise<Currency | undefined> => {
-	const queryClient = getQueryClient();
-
-	let currencies = queryClient.getQueryData([...currencyKeys.lists, chainId]) as
-		| Currency[]
-		| undefined;
+export type UseCurrencyParams = Optional<CurrencyQueryOptions, 'config'>;
 
-	if (!currencies) {
-		const marketplaceClient = getMarketplaceClient(config);
-		currencies = await marketplaceClient
-			.listCurrencies({ chainId: String(chainId) })
-			.then((resp) => resp.currencies);
-	}
+/**
+ * Hook to fetch currency details from the marketplace
+ *
+ * Retrieves detailed information about a specific currency by its contract address.
+ * The currency data is cached from previous currency list calls when possible.
+ *
+ * @param params - Configuration parameters
+ * @param params.chainId - The chain ID (must be number, e.g., 1 for Ethereum, 137 for Polygon)
+ * @param params.currencyAddress - The currency contract address
+ * @param params.query - Optional React Query configuration
+ *
+ * @returns Query result containing currency details
+ *
+ * @example
+ * Basic usage:
+ * ```typescript
+ * const { data, isLoading } = useCurrency({
+ *   chainId: 137,
+ *   currencyAddress: '0x...'
+ * })
+ * ```
+ *
+ * @example
+ * With custom query options:
+ * ```typescript
+ * const { data, isLoading } = useCurrency({
+ *   chainId: 1,
+ *   currencyAddress: '0x...',
+ *   query: {
+ *     enabled: Boolean(selectedCurrency)
+ *   }
+ * })
+ * ```
+ */
+export function useCurrency(params: UseCurrencyParams) {
+	const defaultConfig = useConfig();
 
-	if (!currencies?.length) {
-		throw new Error('No currencies returned');
-	}
-	const currency = currencies.find(
-		(currency) =>
-			currency.contractAddress.toLowerCase() === currencyAddress.toLowerCase(),
-	);
+	const { config = defaultConfig, ...rest } = params;
 
-	if (!currency) {
-		throw new Error('Currency not found');
-	}
-
-	return currency;
-};
-
-export const currencyOptions = (args: UseCurrencyArgs, config: SdkConfig) => {
-	const { chainId, currencyAddress } = args;
+	const queryOptions = currencyQueryOptions({
+		config,
+		...rest,
+	});
 
-	return queryOptions({
-		...args.query,
-		queryKey: [...currencyKeys.details, args.chainId, args.currencyAddress],
-		queryFn:
-			chainId && currencyAddress
-				? () => fetchCurrency(chainId, currencyAddress, config)
-				: skipToken,
+	return useQuery({
+		...queryOptions,
 	});
-};
+}
+
+export { currencyQueryOptions };
 
-export const useCurrency = (args: UseCurrencyArgs) => {
-	const config = useConfig();
-	return useQuery(currencyOptions(args, config));
-};
+export type { FetchCurrencyParams, CurrencyQueryOptions };