@0xsequence/marketplace-sdk 0.8.11 → 0.9.0

package/src/react/hooks/useComparePrices.tsx

@@ -1,49 +1,46 @@
 import { queryOptions, useQuery } from '@tanstack/react-query';
-import { z } from 'zod';
+import type { Address } from 'viem';
 import type { SdkConfig } from '../../types';
-import { AddressSchema, QueryArgSchema, currencyKeys } from '../_internal';
+import { currencyKeys, type QueryArg } from '../_internal';
 import { useConfig } from './useConfig';
 import { convertPriceToUSD } from './useConvertPriceToUSD';
 
-const UseComparePricesArgsSchema = z.object({
-	chainId: z.number(),
+export interface UseComparePricesArgs {
+	chainId: number;
 	// First price details
-	priceAmountRaw: z.string(),
-	priceCurrencyAddress: AddressSchema,
+	priceAmountRaw: string;
+	priceCurrencyAddress: Address;
 	// Second price details (to compare against)
-	compareToPriceAmountRaw: z.string(),
-	compareToPriceCurrencyAddress: AddressSchema,
-	query: QueryArgSchema,
-});
+	compareToPriceAmountRaw: string;
+	compareToPriceCurrencyAddress: Address;
+	query: QueryArg;
+}
 
-type UseComparePricesArgs = z.input<typeof UseComparePricesArgsSchema>;
-
-export type UseComparePricesReturn = {
+export interface UseComparePricesReturn {
 	percentageDifference: number;
 	percentageDifferenceFormatted: string;
 	status: 'above' | 'same' | 'below';
-};
+}
 
 const comparePrices = async (
 	args: UseComparePricesArgs,
 	config: SdkConfig,
 ): Promise<UseComparePricesReturn> => {
-	const parsedArgs = UseComparePricesArgsSchema.parse(args);
 	const [priceUSD, compareToPriceUSD] = await Promise.all([
 		convertPriceToUSD(
 			{
-				chainId: parsedArgs.chainId,
-				currencyAddress: parsedArgs.priceCurrencyAddress,
-				amountRaw: parsedArgs.priceAmountRaw,
+				chainId: args.chainId,
+				currencyAddress: args.priceCurrencyAddress,
+				amountRaw: args.priceAmountRaw,
 				query: {},
 			},
 			config,
 		),
 		convertPriceToUSD(
 			{
-				chainId: parsedArgs.chainId,
-				currencyAddress: parsedArgs.compareToPriceCurrencyAddress,
-				amountRaw: parsedArgs.compareToPriceAmountRaw,
+				chainId: args.chainId,
+				currencyAddress: args.compareToPriceCurrencyAddress,
+				amountRaw: args.compareToPriceAmountRaw,
 				query: {},
 			},
 			config,

package/src/react/hooks/useConvertPriceToUSD.tsx

@@ -1,26 +1,18 @@
 import { queryOptions, useQuery } from '@tanstack/react-query';
-import { formatUnits } from 'viem';
-import { z } from 'zod';
+import { type Address, formatUnits } from 'viem';
 import type { SdkConfig } from '../../types';
-import {
-	AddressSchema,
-	QueryArgSchema,
-	currencyKeys,
-	getQueryClient,
-} from '../_internal';
-import { currenciesOptions } from '../queries/marketCurrencies';
+import { type Currency, currencyKeys, getQueryClient } from '../_internal';
+import { marketCurrenciesQueryOptions } from '../queries/marketCurrencies';
 import { useConfig } from './useConfig';
 
-const UseConvertPriceToUSDArgsSchema = z.object({
-	chainId: z.number(),
-	currencyAddress: AddressSchema,
-	amountRaw: z.string(),
-	query: QueryArgSchema,
-});
-
-export type UseConvertPriceToUSDArgs = z.input<
-	typeof UseConvertPriceToUSDArgsSchema
->;
+export interface UseConvertPriceToUSDArgs {
+	chainId: number;
+	currencyAddress: Address;
+	amountRaw: string;
+	query?: {
+		enabled?: boolean;
+	};
+}
 
 export type UseConvertPriceToUSDReturn = {
 	usdAmount: number;
@@ -31,20 +23,16 @@ export const convertPriceToUSD = async (
 	args: UseConvertPriceToUSDArgs,
 	config: SdkConfig,
 ): Promise<UseConvertPriceToUSDReturn> => {
-	const parsedArgs = UseConvertPriceToUSDArgsSchema.parse(args);
 	const queryClient = getQueryClient();
-	const currencies = await queryClient.fetchQuery(
-		currenciesOptions(
-			{
-				chainId: parsedArgs.chainId,
-			},
+	const currencies = (await queryClient.fetchQuery(
+		marketCurrenciesQueryOptions({
+			chainId: args.chainId,
 			config,
-		),
-	);
+		}),
+	)) as Currency[];
 	const currencyDetails = currencies.find(
-		(c) =>
-			c.contractAddress.toLowerCase() ===
-			parsedArgs.currencyAddress.toLowerCase(),
+		(c: Currency) =>
+			c.contractAddress.toLowerCase() === args.currencyAddress.toLowerCase(),
 	);
 
 	if (!currencyDetails) {
@@ -52,7 +40,7 @@ export const convertPriceToUSD = async (
 	}
 
 	const amountDecimal = Number(
-		formatUnits(BigInt(parsedArgs.amountRaw), currencyDetails.decimals),
+		formatUnits(BigInt(args.amountRaw), currencyDetails.decimals),
 	);
 	const usdAmount = amountDecimal * currencyDetails.exchangeRate;
 
@@ -68,12 +56,7 @@ export const convertPriceToUSDOptions = (
 ) => {
 	return queryOptions({
 		...args.query,
-		queryKey: [
-			...currencyKeys.conversion,
-			args.chainId,
-			args.currencyAddress,
-			args.amountRaw,
-		],
+		queryKey: [...currencyKeys.conversion, args],
 		queryFn: () => convertPriceToUSD(args, config),
 	});
 };

package/src/react/hooks/useCountListingsForCollectible.tsx

@@ -1,63 +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(parsedArgs.chainId, config);
-	return marketplaceClient.getCountOfListingsForCollectible({
-		...parsedArgs,
-		contractAddress: parsedArgs.collectionAddress,
-		tokenId: parsedArgs.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,76 +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(parsedArgs.chainId, config);
-	if (parsedArgs.filter) {
-		return marketplaceClient
-			.getCountOfFilteredCollectibles({
-				...parsedArgs,
-				contractAddress: parsedArgs.collectionAddress,
-				// biome-ignore lint/style/noNonNullAssertion: safe to assert here, as it's validated
-				side: parsedArgs.side!,
-			})
-			.then((resp) => resp.count);
-	}
-	return marketplaceClient
-		.getCountOfAllCollectibles({
-			...parsedArgs,
-			contractAddress: parsedArgs.collectionAddress,
-		})
-		.then((resp) => resp.count);
-};
+	const { config = defaultConfig, ...rest } = params;
 
-export const countOfCollectablesOptions = (
-	args: UseCountOfCollectablesArgs,
-	config: SdkConfig,
-) => {
-	return queryOptions({
-		...args.query,
-		queryKey: [...collectableKeys.counts, args],
-		queryFn: () => fetchCountOfCollectables(args, config),
+	const queryOptions = countOfCollectablesQueryOptions({
+		config,
+		...rest,
 	});
-};
 
-export const useCountOfCollectables = (args: UseCountOfCollectablesArgs) => {
-	const config = useConfig();
-	return useQuery(countOfCollectablesOptions(args, config));
-};
+	return useQuery({
+		...queryOptions,
+	});
+}
+
+export { countOfCollectablesQueryOptions };
+
+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,63 +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(parsedArgs.chainId, config);
-	return marketplaceClient.getCountOfOffersForCollectible({
-		...parsedArgs,
-		contractAddress: parsedArgs.collectionAddress,
-		tokenId: parsedArgs.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,
 };