@0xsequence/marketplace-sdk 0.8.12 → 0.10.0

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/useGetCountOfPrimarySaleItems.tsx

@@ -0,0 +1,48 @@
+'use client';
+
+import { useQuery } from '@tanstack/react-query';
+import type { Optional } from '../_internal';
+import type { ListPrimarySaleItemsQueryOptions } from '../queries/primarySaleItems';
+import { primarySaleItemsCountQueryOptions } from '../queries/primarySaleItemsCount';
+import { useConfig } from './useConfig';
+
+export type UseGetCountParams = Optional<
+	ListPrimarySaleItemsQueryOptions,
+	'config'
+>;
+
+/**
+ * Hook to get the total count of primary sale items
+ *
+ * Retrieves the total count of primary sale items for a specific contract address
+ * 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.primarySaleContractAddress - The primary sale contract address
+ * @param params.filter - Optional filter parameters for the query
+ * @param params.query - Optional React Query configuration
+ *
+ * @returns Query result containing the count of primary sale items
+ *
+ * @example
+ * ```typescript
+ * const { data: count, isLoading } = useGetCountOfPrimarySaleItems({
+ *   chainId: 137,
+ *   primarySaleContractAddress: '0x...',
+ * })
+ * ```
+ */
+export function useGetCountOfPrimarySaleItems(params: UseGetCountParams) {
+	const defaultConfig = useConfig();
+	const { config = defaultConfig, ...rest } = params;
+
+	const queryOptions = primarySaleItemsCountQueryOptions({
+		config,
+		...rest,
+	});
+
+	return useQuery(queryOptions);
+}
+
+export type { ListPrimarySaleItemsQueryOptions };

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,92 @@
+'use client';
+
+import { useQuery } from '@tanstack/react-query';
+import type { Address } from 'viem';
+import type { Optional } from '../_internal';
+import {
+	type FetchGetTokenRangesParams,
+	type GetTokenRangesQueryOptions,
+	getTokenRangesQueryOptions,
+} from '../queries/getTokenRanges';
+import { useConfig } from './useConfig';
+
+export type UseGetTokenRangesParams = Optional<
+	GetTokenRangesQueryOptions,
+	'config'
+>;
+
+/**
+ * Hook to fetch token ID ranges for a collection
+ *
+ * Retrieves the available token ID ranges for a specific collection,
+ * which is useful for understanding the token distribution and
+ * available tokens within a 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 to fetch ranges for
+ * @param params.query - Optional React Query configuration
+ *
+ * @returns Query result containing token ID ranges for the collection
+ *
+ * @example
+ * Basic usage:
+ * ```typescript
+ * const { data: tokenRanges, isLoading } = useGetTokenRanges({
+ *   chainId: 137,
+ *   collectionAddress: '0x1234...'
+ * })
+ *
+ * if (data) {
+ *   console.log(`Token ranges: ${JSON.stringify(data.tokenIDRanges)}`);
+ *   data.tokenIDRanges?.forEach(range => {
+ *     console.log(`Range: ${range.start} - ${range.end}`);
+ *   });
+ * }
+ * ```
+ *
+ * @example
+ * With conditional enabling:
+ * ```typescript
+ * const { data: tokenRanges } = useGetTokenRanges({
+ *   chainId: 1,
+ *   collectionAddress: selectedCollection?.address,
+ *   query: {
+ *     enabled: Boolean(selectedCollection?.address),
+ *     staleTime: 300000, // Cache for 5 minutes
+ *     refetchInterval: 60000 // Refresh every minute
+ *   }
+ * })
+ * ```
+ */
+export function useGetTokenRanges(params: UseGetTokenRangesParams) {
+	const defaultConfig = useConfig();
+
+	const { config = defaultConfig, ...rest } = params;
+
+	const queryOptions = getTokenRangesQueryOptions({
+		config,
+		...rest,
+	});
+
+	return useQuery({
+		...queryOptions,
+	});
+}
+
+export { getTokenRangesQueryOptions };
+
+export type { FetchGetTokenRangesParams, GetTokenRangesQueryOptions };
+
+// Legacy exports for backward compatibility
+export type UseGetTokenRangesProps = {
+	chainId: number;
+	collectionAddress: Address;
+	query?: {
+		enabled?: boolean;
+	};
+};
+
+export type UseGetTokenRangesReturn = Awaited<
+	ReturnType<typeof import('../queries/getTokenRanges').fetchGetTokenRanges>
+>;

package/src/react/hooks/useHighestOffer.tsx

@@ -1,8 +1,72 @@
+'use client';
+
 import { useQuery } from '@tanstack/react-query';
-import { type UseHighestOfferArgs, highestOfferOptions } from '../queries';
+import type { Optional } from '../_internal';
+import {
+	type FetchHighestOfferParams,
+	type HighestOfferQueryOptions,
+	highestOfferQueryOptions,
+} from '../queries/highestOffer';
 import { useConfig } from './useConfig';
 
-export function useHighestOffer(args: UseHighestOfferArgs) {
-	const config = useConfig();
-	return useQuery(highestOfferOptions(args, config));
+export type UseHighestOfferParams = Optional<
+	HighestOfferQueryOptions,
+	'config'
+>;
+
+/**
+ * Hook to fetch the highest offer for a collectible
+ *
+ * Retrieves the highest offer currently available for a specific token
+ * in a 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.tokenId - The token ID within the collection
+ * @param params.query - Optional React Query configuration
+ *
+ * @returns Query result containing the highest offer data or null if no offers exist
+ *
+ * @example
+ * Basic usage:
+ * ```typescript
+ * const { data, isLoading } = useHighestOffer({
+ *   chainId: 137,
+ *   collectionAddress: '0x...',
+ *   tokenId: '1'
+ * })
+ * ```
+ *
+ * @example
+ * With custom query options:
+ * ```typescript
+ * const { data, isLoading } = useHighestOffer({
+ *   chainId: 1,
+ *   collectionAddress: '0x...',
+ *   tokenId: '42',
+ *   query: {
+ *     refetchInterval: 15000,
+ *     enabled: hasTokenId
+ *   }
+ * })
+ * ```
+ */
+export function useHighestOffer(params: UseHighestOfferParams) {
+	const defaultConfig = useConfig();
+
+	const { config = defaultConfig, ...rest } = params;
+
+	const queryOptions = highestOfferQueryOptions({
+		config,
+		...rest,
+	});
+
+	return useQuery({
+		...queryOptions,
+	});
 }
+
+export { highestOfferQueryOptions };
+
+export type { FetchHighestOfferParams, HighestOfferQueryOptions };

package/src/react/hooks/useInventory.tsx

@@ -1,6 +1,6 @@
 import { useInfiniteQuery } from '@tanstack/react-query';
 import { ContractType } from '../_internal';
-import { type UseInventoryArgs, inventoryOptions } from '../queries/inventory';
+import { inventoryOptions, type UseInventoryArgs } from '../queries/inventory';
 import { useConfig } from './useConfig';
 import { useMarketplaceConfig } from './useMarketplaceConfig';
 

package/src/react/hooks/useList1155ShopCardData.tsx

@@ -1,14 +1,11 @@
 import type { Address } from 'viem';
 import { useReadContract } from 'wagmi';
-import {
-	ContractType,
-	ERC1155_SALES_CONTRACT_ABI,
-	type TokenMetadata,
-} from '../../../../sdk/src';
-import type { ShopCollectibleCardProps } from '../ui/components/marketplace-collectible-card';
-import { useCollectionDetails } from './useCollectionDetails';
-import { useListTokenMetadata } from './useListTokenMetadata';
-import { useTokenSaleDetailsBatch } from './useTokenSaleDetailsBatch';
+import { ERC1155_SALES_CONTRACT_ABI } from '../../utils';
+import { ContractType, type TokenMetadata } from '../_internal';
+import type { ShopCollectibleCardProps } from '../ui/components/marketplace-collectible-card/types';
+import { useCollection } from './useCollection';
+import { useFilterState } from './useFilterState';
+import { useListPrimarySaleItems } from './useListPrimarySaleItems';
 
 interface UseList1155ShopCardDataProps {
 	tokenIds: string[];
@@ -25,106 +22,84 @@ export function useList1155ShopCardData({
 	salesContractAddress,
 	enabled = true,
 }: UseList1155ShopCardDataProps) {
+	const { showListedOnly } = useFilterState();
 	const {
-		data: tokenMetadata,
-		isLoading: tokenMetadataLoading,
-		error: tokenMetadataError,
-	} = useListTokenMetadata({
+		data: primarySaleItems,
+		isLoading: primarySaleItemsLoading,
+		error: primarySaleItemsError,
+	} = useListPrimarySaleItems({
 		chainId,
-		contractAddress,
-		tokenIds,
-		query: {
-			enabled,
+		primarySaleContractAddress: salesContractAddress,
+		filter: {
+			includeEmpty: !showListedOnly,
 		},
 	});
 
-	const {
-		data: collectionDetails,
-		error: collectionDetailsError,
-		isLoading: collectionDetailsLoading,
-	} = useCollectionDetails({
+	const { data: collection, isLoading: collectionLoading } = useCollection({
 		chainId,
 		collectionAddress: contractAddress,
-		query: {
-			enabled,
-		},
 	});
 
-	const {
-		extendedSupplyData,
-		getInitialSupply,
-		getRemainingSupply,
-		loading: tokenSaleDetailsLoading,
-		error: tokenSaleDetailsError,
-	} = useTokenSaleDetailsBatch({
-		collectionAddress: contractAddress,
-		tokenIds,
-		salesContractAddress,
-		chainId,
-		query: {
-			enabled,
-		},
-	});
-
-	const { data: paymentToken } = useReadContract({
-		chainId,
-		address: salesContractAddress,
-		abi: ERC1155_SALES_CONTRACT_ABI,
-		functionName: 'paymentToken',
-		query: {
-			enabled,
-		},
-	});
+	const { data: paymentToken, isLoading: paymentTokenLoading } =
+		useReadContract({
+			chainId,
+			address: salesContractAddress,
+			abi: ERC1155_SALES_CONTRACT_ABI,
+			functionName: 'paymentToken',
+			query: {
+				enabled,
+			},
+		});
 
 	const isLoading =
-		tokenSaleDetailsLoading || tokenMetadataLoading || collectionDetailsLoading;
+		primarySaleItemsLoading || collectionLoading || paymentTokenLoading;
 
-	const collectibleCards = tokenIds.map((tokenId) => {
-		const token = tokenMetadata?.find((token) => token.tokenId === tokenId);
+	// Flatten all collectibles from all pages
+	const allPrimarySaleItems =
+		primarySaleItems?.pages.flatMap((page) => page.primarySaleItems) ?? [];
 
-		const saleData = extendedSupplyData?.find(
-			(data) => data.tokenId === tokenId,
+	const collectibleCards = tokenIds.map((tokenId) => {
+		const matchingPrimarySaleItem = allPrimarySaleItems.find(
+			(item) => item.primarySaleItem.tokenId?.toString() === tokenId,
 		);
 
-		const cost =
-			saleData && typeof saleData.result === 'object'
-				? saleData.result.cost?.toString() || ''
-				: '';
-		const saleStartsAt =
-			saleData && typeof saleData.result === 'object'
-				? saleData.result.startTime?.toString()
-				: undefined;
-		const saleEndsAt =
-			saleData && typeof saleData.result === 'object'
-				? saleData.result.endTime?.toString()
-				: undefined;
+		const saleData = matchingPrimarySaleItem?.primarySaleItem;
+		const tokenMetadata =
+			matchingPrimarySaleItem?.metadata || ({} as TokenMetadata);
+
+		const salePrice = {
+			amount: saleData?.priceAmount?.toString() || '',
+			currencyAddress: (saleData?.currencyAddress ||
+				paymentToken ||
+				'0x') as Address,
+		};
+
+		const supply = saleData?.supply?.toString();
+		const unlimitedSupply = saleData?.unlimitedSupply;
 
 		return {
 			collectibleId: tokenId,
 			chainId,
-			collectionAddress: contractAddress as Address,
+			collectionAddress: contractAddress,
 			collectionType: ContractType.ERC1155,
-			tokenMetadata: token as TokenMetadata,
+			tokenMetadata: tokenMetadata,
 			cardLoading: isLoading,
-			salesContractAddress: salesContractAddress as Address,
-			salePrice: {
-				amount: cost,
-				currencyAddress: paymentToken ?? ('0x' as Address),
-			},
-			quantityInitial: getInitialSupply(tokenId)?.toString() ?? undefined,
-			quantityDecimals: collectionDetails?.tokenQuantityDecimals,
-			quantityRemaining: getRemainingSupply(tokenId)?.toString(),
-			saleStartsAt,
-			saleEndsAt,
+			salesContractAddress: salesContractAddress,
+			salePrice,
+			quantityInitial: supply,
+			quantityDecimals: collection?.decimals || 0,
+			quantityRemaining: supply,
+			unlimitedSupply,
+			saleStartsAt: saleData?.startDate?.toString(),
+			saleEndsAt: saleData?.endDate?.toString(),
 			marketplaceType: 'shop',
 		} satisfies ShopCollectibleCardProps;
 	});
 
 	return {
 		collectibleCards,
-		tokenMetadataError,
-		tokenSaleDetailsError,
-		collectionDetailsError,
+		tokenMetadataError: primarySaleItemsError,
+		tokenSaleDetailsError: null,
 		isLoading,
 	};
 }