@0xsequence/marketplace-sdk 0.8.12 → 0.9.0

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 };

package/src/react/hooks/useFilterState.tsx

@@ -1,5 +1,3 @@
-import { useMemo } from 'react';
-
 import {
 	createSerializer,
 	parseAsBoolean,
@@ -7,6 +5,7 @@ import {
 	parseAsString,
 	useQueryState,
 } from 'nuqs';
+import { useMemo } from 'react';
 import { type PropertyFilter, PropertyType } from '../_internal';
 
 interface StringFilterValues {

package/src/react/hooks/useFloorOrder.tsx

@@ -1,45 +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,
-	QueryArgSchema,
-	collectableKeys,
-	getMarketplaceClient,
-} from '../_internal';
+	type FetchFloorOrderParams,
+	type FloorOrderQueryOptions,
+	floorOrderQueryOptions,
+} from '../queries/floorOrder';
 import { useConfig } from './useConfig';
 
-const UseFloorOrderSchema = z.object({
-	chainId: z.number(),
-	collectionAddress: AddressSchema,
-	query: QueryArgSchema,
-});
-
-export type UseFloorOrderArgs = z.infer<typeof UseFloorOrderSchema>;
-
-export type UseFloorOrderReturn = Awaited<ReturnType<typeof fetchFloorOrder>>;
-
-const fetchFloorOrder = async (args: UseFloorOrderArgs, config: SdkConfig) => {
-	const marketplaceClient = getMarketplaceClient(config);
-	return marketplaceClient
-		.getFloorOrder({
-			chainId: String(args.chainId),
-			contractAddress: args.collectionAddress,
-		})
-		.then((data) => data.collectible);
-};
-
-export const floorOrderOptions = (
-	args: UseFloorOrderArgs,
-	config: SdkConfig,
-) => {
-	return queryOptions({
-		queryKey: [...collectableKeys.floorOrders, args, config],
-		queryFn: () => fetchFloorOrder(args, config),
+export type UseFloorOrderParams = Optional<FloorOrderQueryOptions, 'config'>;
+
+/**
+ * Hook to fetch the floor order for a collection
+ *
+ * Retrieves the lowest priced order (listing) currently available for any token
+ * in the specified collection from the marketplace.
+ *
+ * @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.query - Optional React Query configuration
+ *
+ * @returns Query result containing the floor order data for the collection
+ *
+ * @example
+ * Basic usage:
+ * ```typescript
+ * const { data, isLoading } = useFloorOrder({
+ *   chainId: 137,
+ *   collectionAddress: '0x...'
+ * })
+ * ```
+ *
+ * @example
+ * With filters and custom query options:
+ * ```typescript
+ * const { data, isLoading } = useFloorOrder({
+ *   chainId: 1,
+ *   collectionAddress: '0x...',
+ *   filter: {
+ *     minPrice: '1000000000000000000' // 1 ETH in wei
+ *   },
+ *   query: {
+ *     refetchInterval: 30000,
+ *     enabled: hasCollectionAddress
+ *   }
+ * })
+ * ```
+ */
+export function useFloorOrder(params: UseFloorOrderParams) {
+	const defaultConfig = useConfig();
+
+	const { config = defaultConfig, ...rest } = params;
+
+	const queryOptions = floorOrderQueryOptions({
+		config,
+		...rest,
 	});
-};
 
-export const useFloorOrder = (args: UseFloorOrderArgs) => {
-	const config = useConfig();
-	return useQuery(floorOrderOptions(args, config));
-};
+	return useQuery({
+		...queryOptions,
+	});
+}
+
+export { floorOrderQueryOptions };
+
+export type { FetchFloorOrderParams, FloorOrderQueryOptions };

package/src/react/hooks/useGenerateCancelTransaction.tsx

@@ -1,11 +1,10 @@
 import { useMutation } from '@tanstack/react-query';
-import { z } from 'zod';
 import type { SdkConfig } from '../../types';
 import {
 	type GenerateCancelTransactionArgs,
 	getMarketplaceClient,
 } from '../_internal';
-import { stepSchema } from '../_internal/api/zod-schema';
+import type { Step } from '../_internal/api/marketplace.gen';
 import { useConfig } from './useConfig';
 
 // Create a type that uses number for chainId
@@ -16,14 +15,10 @@ type GenerateCancelTransactionArgsWithNumberChainId = Omit<
 	chainId: number;
 };
 
-const UserGenerateCancelTransactionArgsSchema = z.object({
-	chainId: z.number(),
-	onSuccess: z.function().args(stepSchema.array().optional()).optional(),
-});
-
-type UseGenerateCancelTransactionArgs = z.infer<
-	typeof UserGenerateCancelTransactionArgsSchema
->;
+interface UseGenerateCancelTransactionArgs {
+	chainId: number;
+	onSuccess?: (steps?: Step[]) => void;
+}
 
 export const generateCancelTransaction = async (
 	args: GenerateCancelTransactionArgsWithNumberChainId,

package/src/react/hooks/useGenerateListingTransaction.tsx

@@ -11,8 +11,8 @@ import { dateToUnixTime } from '../../utils/date';
 import {
 	type CreateReq,
 	type GenerateListingTransactionArgs,
-	type Step,
 	getMarketplaceClient,
+	type Step,
 } from '../_internal';
 
 export type CreateReqWithDateExpiry = Omit<CreateReq, 'expiry'> & {

package/src/react/hooks/useGenerateOfferTransaction.tsx

@@ -4,9 +4,9 @@ import { dateToUnixTime } from '../../utils/date';
 import {
 	type CreateReq,
 	type GenerateOfferTransactionArgs,
+	getMarketplaceClient,
 	type Step,
 	type WalletKind,
-	getMarketplaceClient,
 } from '../_internal';
 import { useWallet } from '../_internal/wallet/useWallet';
 import { useConfig } from './useConfig';

package/src/react/hooks/useGenerateSellTransaction.tsx

@@ -1,21 +1,16 @@
 import { useMutation } from '@tanstack/react-query';
-import { z } from 'zod';
 import type { SdkConfig } from '../../types';
 import {
 	type GenerateSellTransactionArgs,
 	getMarketplaceClient,
 } from '../_internal';
-import { stepSchema } from '../_internal/api/zod-schema';
+import type { Step } from '../_internal/api/marketplace.gen';
 import { useConfig } from './useConfig';
 
-const UserGeneratSellTransactionArgsSchema = z.object({
-	chainId: z.number(),
-	onSuccess: z.function().args(stepSchema.array().optional()).optional(),
-});
-
-type UseGenerateSellTransactionArgs = z.infer<
-	typeof UserGeneratSellTransactionArgsSchema
->;
+interface UseGenerateSellTransactionArgs {
+	chainId: number;
+	onSuccess?: (steps?: Step[]) => void;
+}
 
 type GenerateSellTransactionArgsWithNumberChainId = Omit<
 	GenerateSellTransactionArgs,

package/src/react/hooks/useGetReceiptFromHash.tsx

@@ -3,11 +3,40 @@ import type { Hex } from 'viem';
 import { usePublicClient } from 'wagmi';
 
 /**
- * @returns a function to wait for a transaction receipt and the receipt
- * @description This hook is used to wait for a transaction receipt and the receipt
+ * Hook to get transaction receipt from hash
+ *
+ * Provides a function to wait for a transaction receipt using a transaction hash.
+ * This is a wagmi-based hook for direct blockchain interaction.
+ *
+ * @returns Object containing waitForReceipt function
+ *
  * @example
+ * Basic usage:
+ * ```typescript
  * const { waitForReceipt } = useGetReceiptFromHash();
- * const receipt = await waitForReceipt(transactionHash);
+ *
+ * // Wait for transaction receipt
+ * const receipt = await waitForReceipt('0x123...');
+ * console.log('Transaction status:', receipt.status);
+ * ```
+ *
+ * @example
+ * In transaction flow:
+ * ```typescript
+ * const { waitForReceipt } = useGetReceiptFromHash();
+ *
+ * const handleTransaction = async () => {
+ *   try {
+ *     const hash = await writeContract({ ... });
+ *     const receipt = await waitForReceipt(hash);
+ *     if (receipt.status === 'success') {
+ *       console.log('Transaction confirmed!');
+ *     }
+ *   } catch (error) {
+ *     console.error('Transaction failed:', error);
+ *   }
+ * };
+ * ```
  */
 export const useGetReceiptFromHash = () => {
 	const publicClient = usePublicClient();