@0xsequence/marketplace-sdk 0.8.11 → 0.9.0

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(chainId, config);
-		currencies = await marketplaceClient
-			.listCurrencies()
-			.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/useERC721SaleMintedTokens.tsx

@@ -0,0 +1,67 @@
+import type { Address } from 'viem';
+import { useReadContract } from 'wagmi';
+import { ERC721_SALE_ABI } from '../../../../sdk/src';
+import { useGetTokenSuppliesMap } from './useGetTokenSuppliesMap';
+
+interface UseERC721SaleMintedTokensProps {
+	chainId: number;
+	contractAddress: Address;
+	salesContractAddress: Address;
+	enabled?: boolean;
+	tokenIds: string[];
+}
+
+export function useERC721SaleMintedTokens({
+	chainId,
+	contractAddress,
+	salesContractAddress,
+	tokenIds,
+	enabled = true,
+}: UseERC721SaleMintedTokensProps) {
+	const {
+		data: saleDetails,
+		isLoading: saleDetailsLoading,
+		error: saleDetailsError,
+	} = useReadContract({
+		chainId,
+		address: salesContractAddress,
+		abi: ERC721_SALE_ABI,
+		functionName: 'saleDetails',
+		query: {
+			enabled,
+		},
+	});
+
+	// Get token supplies for all potential tokens in the sale
+	const { data: tokenSupplies, isLoading: tokenSuppliesLoading } =
+		useGetTokenSuppliesMap({
+			chainId,
+			tokenIds,
+			collectionAddress: contractAddress as Address,
+		});
+
+	const isLoading = saleDetailsLoading || tokenSuppliesLoading;
+
+	// Count how many tokens have been minted/owned
+	const ownedCount = tokenIds.reduce((count, tokenId) => {
+		const supplies = tokenSupplies?.supplies[contractAddress];
+		const supply = supplies?.find((s) => s.tokenID === tokenId);
+		// If supply exists and is greater than 0, token exists and is owned
+		const hasOwner = supply ? BigInt(supply.supply) > 0n : false;
+		return count + (hasOwner ? 1 : 0);
+	}, 0);
+
+	const totalSupplyCap = saleDetails?.supplyCap
+		? Number(saleDetails.supplyCap)
+		: 0;
+	const remainingCount = Math.max(0, totalSupplyCap - ownedCount);
+
+	return {
+		ownedCount,
+		totalSupplyCap,
+		remainingCount,
+		isLoading,
+		error: saleDetailsError,
+		saleDetails,
+	};
+}

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,42 +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(args.chainId, config);
-	return marketplaceClient
-		.getFloorOrder({ 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,30 +1,32 @@
 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';
 
-const UserGenerateCancelTransactionArgsSchema = z.object({
-	chainId: z.number(),
-	onSuccess: z.function().args(stepSchema.array().optional()).optional(),
-});
+// Create a type that uses number for chainId
+type GenerateCancelTransactionArgsWithNumberChainId = Omit<
+	GenerateCancelTransactionArgs,
+	'chainId'
+> & {
+	chainId: number;
+};
 
-type UseGenerateCancelTransactionArgs = z.infer<
-	typeof UserGenerateCancelTransactionArgsSchema
->;
+interface UseGenerateCancelTransactionArgs {
+	chainId: number;
+	onSuccess?: (steps?: Step[]) => void;
+}
 
 export const generateCancelTransaction = async (
-	args: GenerateCancelTransactionArgs,
+	args: GenerateCancelTransactionArgsWithNumberChainId,
 	config: SdkConfig,
-	chainId: number,
 ) => {
-	const marketplaceClient = getMarketplaceClient(chainId, config);
+	const marketplaceClient = getMarketplaceClient(config);
 	return marketplaceClient
-		.generateCancelTransaction(args)
+		.generateCancelTransaction({ ...args, chainId: String(args.chainId) })
 		.then((data) => data.steps);
 };
 
@@ -35,8 +37,8 @@ export const useGenerateCancelTransaction = (
 
 	const { mutate, mutateAsync, ...result } = useMutation({
 		onSuccess: params.onSuccess,
-		mutationFn: (args: GenerateCancelTransactionArgs) =>
-			generateCancelTransaction(args, config, params.chainId),
+		mutationFn: (args: GenerateCancelTransactionArgsWithNumberChainId) =>
+			generateCancelTransaction(args, config),
 	});
 
 	return {

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'> & {
@@ -26,19 +26,27 @@ export type GenerateListingTransactionProps = Omit<
 	listing: CreateReqWithDateExpiry;
 };
 
+type GenerateListingTransactionArgsWithNumberChainId = Omit<
+	GenerateListingTransactionArgs,
+	'chainId' | 'listing'
+> & {
+	chainId: number;
+	listing: CreateReqWithDateExpiry;
+};
+
 export const generateListingTransaction = async (
-	params: GenerateListingTransactionProps,
+	params: GenerateListingTransactionArgsWithNumberChainId,
 	config: SdkConfig,
-	chainId: number,
 ) => {
 	const args = {
 		...params,
+		chainId: String(params.chainId),
 		listing: {
 			...params.listing,
 			expiry: dateToUnixTime(params.listing.expiry),
 		},
 	} satisfies GenerateListingTransactionArgs;
-	const marketplaceClient = getMarketplaceClient(chainId, config);
+	const marketplaceClient = getMarketplaceClient(config);
 	return (await marketplaceClient.generateListingTransaction(args)).steps;
 };
 
@@ -49,8 +57,10 @@ export const useGenerateListingTransaction = (
 
 	const { mutate, mutateAsync, ...result } = useMutation({
 		onSuccess: params.onSuccess,
-		mutationFn: (args: GenerateListingTransactionProps) =>
-			generateListingTransaction(args, config, params.chainId),
+		mutationFn: (
+			args: Omit<GenerateListingTransactionArgsWithNumberChainId, 'chainId'>,
+		) =>
+			generateListingTransaction({ ...args, chainId: params.chainId }, config),
 	});
 
 	return {

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';
@@ -27,18 +27,26 @@ export type GenerateOfferTransactionProps = Omit<
 	offer: CreateReqWithDateExpiry;
 };
 
+type GenerateOfferTransactionArgsWithNumberChainId = Omit<
+	GenerateOfferTransactionArgs,
+	'chainId' | 'offer'
+> & {
+	chainId: number;
+	offer: CreateReqWithDateExpiry;
+};
+
 export const generateOfferTransaction = async (
-	params: GenerateOfferTransactionProps,
+	params: GenerateOfferTransactionArgsWithNumberChainId,
 	config: SdkConfig,
-	chainId: number,
 	walletKind?: WalletKind,
 ) => {
 	const args = {
 		...params,
+		chainId: String(params.chainId),
 		offer: { ...params.offer, expiry: dateToUnixTime(params.offer.expiry) },
 		walletType: walletKind,
 	} satisfies GenerateOfferTransactionArgs;
-	const marketplaceClient = getMarketplaceClient(chainId, config);
+	const marketplaceClient = getMarketplaceClient(config);
 	return (await marketplaceClient.generateOfferTransaction(args)).steps;
 };
 
@@ -50,11 +58,12 @@ export const useGenerateOfferTransaction = (
 
 	const { mutate, mutateAsync, ...result } = useMutation({
 		onSuccess: params.onSuccess,
-		mutationFn: (args: GenerateOfferTransactionProps) =>
+		mutationFn: (
+			args: Omit<GenerateOfferTransactionArgsWithNumberChainId, 'chainId'>,
+		) =>
 			generateOfferTransaction(
-				args,
+				{ ...args, chainId: params.chainId },
 				config,
-				params.chainId,
 				wallet?.walletKind,
 			),
 	});

package/src/react/hooks/useGenerateSellTransaction.tsx

@@ -1,30 +1,33 @@
 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(),
-});
+interface UseGenerateSellTransactionArgs {
+	chainId: number;
+	onSuccess?: (steps?: Step[]) => void;
+}
 
-type UseGenerateSellTransactionArgs = z.infer<
-	typeof UserGeneratSellTransactionArgsSchema
->;
+type GenerateSellTransactionArgsWithNumberChainId = Omit<
+	GenerateSellTransactionArgs,
+	'chainId'
+> & { chainId: number };
 
 export const generateSellTransaction = async (
-	args: GenerateSellTransactionArgs,
+	args: GenerateSellTransactionArgsWithNumberChainId,
 	config: SdkConfig,
-	chainId: number,
 ) => {
-	const marketplaceClient = getMarketplaceClient(chainId, config);
+	const marketplaceClient = getMarketplaceClient(config);
+	const argsWithStringChainId = {
+		...args,
+		chainId: String(args.chainId),
+	} satisfies GenerateSellTransactionArgs;
 	return marketplaceClient
-		.generateSellTransaction(args)
+		.generateSellTransaction(argsWithStringChainId)
 		.then((data) => data.steps);
 };
 
@@ -35,8 +38,9 @@ export const useGenerateSellTransaction = (
 
 	const { mutate, mutateAsync, ...result } = useMutation({
 		onSuccess: params.onSuccess,
-		mutationFn: (args: GenerateSellTransactionArgs) =>
-			generateSellTransaction(args, config, params.chainId),
+		mutationFn: (
+			args: Omit<GenerateSellTransactionArgsWithNumberChainId, 'chainId'>,
+		) => generateSellTransaction({ ...args, chainId: params.chainId }, config),
 	});
 
 	return {

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();

package/src/react/hooks/useGetTokenRanges.tsx

@@ -0,0 +1,31 @@
+import { useQuery } from '@tanstack/react-query';
+import type { Address } from 'viem';
+import { useConfig } from '..';
+import { getIndexerClient } from '../_internal';
+
+interface UseGetTokenRangesProps {
+	chainId: number;
+	collectionAddress: Address;
+	query?: {
+		enabled?: boolean;
+	};
+}
+
+export function useGetTokenRanges({
+	chainId,
+	collectionAddress,
+	query = {},
+}: UseGetTokenRangesProps) {
+	const config = useConfig();
+	const indexerClient = getIndexerClient(chainId, config);
+
+	return useQuery({
+		queryKey: ['indexer-tokenRanges', chainId, collectionAddress],
+		queryFn: () => {
+			return indexerClient.getTokenIDRanges({
+				contractAddress: collectionAddress,
+			});
+		},
+		enabled: query?.enabled,
+	});
+}