@0xsequence/marketplace-sdk 0.8.12 → 0.10.0

package/src/react/hooks/useListTokenMetadata.tsx

@@ -0,0 +1,73 @@
+'use client';
+
+import { useQuery } from '@tanstack/react-query';
+import type { Optional } from '../_internal';
+import {
+	type FetchListTokenMetadataParams,
+	type ListTokenMetadataQueryOptions,
+	listTokenMetadataQueryOptions,
+} from '../queries/listTokenMetadata';
+import { useConfig } from './useConfig';
+
+export type UseListTokenMetadataParams = Optional<
+	ListTokenMetadataQueryOptions,
+	'config'
+>;
+
+/**
+ * Hook to fetch metadata for multiple tokens
+ *
+ * Retrieves metadata for a batch of tokens from a specific contract using the metadata API.
+ * This hook is optimized for fetching multiple token metadata in a single request.
+ *
+ * @param params - Configuration parameters
+ * @param params.chainId - The chain ID (must be number, e.g., 1 for Ethereum, 137 for Polygon)
+ * @param params.contractAddress - The contract address containing the tokens
+ * @param params.tokenIds - Array of token IDs to fetch metadata for
+ * @param params.config - Optional SDK configuration (defaults from context)
+ * @param params.query - Optional React Query configuration
+ *
+ * @returns Query result containing an array of token metadata
+ *
+ * @example
+ * Basic usage:
+ * ```typescript
+ * const { data: metadata, isLoading } = useListTokenMetadata({
+ *   chainId: 137,
+ *   contractAddress: '0x...',
+ *   tokenIds: ['1', '2', '3']
+ * })
+ * ```
+ *
+ * @example
+ * With query options:
+ * ```typescript
+ * const { data: metadata } = useListTokenMetadata({
+ *   chainId: 1,
+ *   contractAddress: '0x...',
+ *   tokenIds: selectedTokenIds,
+ *   query: {
+ *     enabled: selectedTokenIds.length > 0,
+ *     staleTime: 10 * 60 * 1000 // 10 minutes
+ *   }
+ * })
+ * ```
+ */
+export function useListTokenMetadata(params: UseListTokenMetadataParams) {
+	const defaultConfig = useConfig();
+
+	const { config = defaultConfig, ...rest } = params;
+
+	const queryOptions = listTokenMetadataQueryOptions({
+		config,
+		...rest,
+	});
+
+	return useQuery({
+		...queryOptions,
+	});
+}
+
+export { listTokenMetadataQueryOptions };
+
+export type { FetchListTokenMetadataParams, ListTokenMetadataQueryOptions };

package/src/react/hooks/useLowestListing.tsx

@@ -1,8 +1,72 @@
+'use client';
+
 import { useQuery } from '@tanstack/react-query';
-import { type UseLowestListingArgs, lowestListingOptions } from '../queries';
+import type { Optional } from '../_internal';
+import {
+	type FetchLowestListingParams,
+	type LowestListingQueryOptions,
+	lowestListingQueryOptions,
+} from '../queries/lowestListing';
 import { useConfig } from './useConfig';
 
-export function useLowestListing(args: UseLowestListingArgs) {
-	const config = useConfig();
-	return useQuery(lowestListingOptions(args, config));
+export type UseLowestListingParams = Optional<
+	LowestListingQueryOptions,
+	'config'
+>;
+
+/**
+ * Hook to fetch the lowest listing for a collectible
+ *
+ * Retrieves the lowest priced listing 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 lowest listing data or null if no listings exist
+ *
+ * @example
+ * Basic usage:
+ * ```typescript
+ * const { data, isLoading } = useLowestListing({
+ *   chainId: 137,
+ *   collectionAddress: '0x...',
+ *   tokenId: '1'
+ * })
+ * ```
+ *
+ * @example
+ * With custom query options:
+ * ```typescript
+ * const { data, isLoading } = useLowestListing({
+ *   chainId: 1,
+ *   collectionAddress: '0x...',
+ *   tokenId: '42',
+ *   query: {
+ *     refetchInterval: 15000,
+ *     enabled: hasTokenId
+ *   }
+ * })
+ * ```
+ */
+export function useLowestListing(params: UseLowestListingParams) {
+	const defaultConfig = useConfig();
+
+	const { config = defaultConfig, ...rest } = params;
+
+	const queryOptions = lowestListingQueryOptions({
+		config,
+		...rest,
+	});
+
+	return useQuery({
+		...queryOptions,
+	});
 }
+
+export { lowestListingQueryOptions };
+
+export type { FetchLowestListingParams, LowestListingQueryOptions };

package/src/react/hooks/useMarketCurrencies.tsx

@@ -1,8 +1,65 @@
+'use client';
+
 import { useQuery } from '@tanstack/react-query';
-import { type UseMarketCurrenciesArgs, currenciesOptions } from '../queries';
+import type { Optional } from '../_internal';
+import {
+	type FetchMarketCurrenciesParams,
+	type MarketCurrenciesQueryOptions,
+	marketCurrenciesQueryOptions,
+} from '../queries/marketCurrencies';
 import { useConfig } from './useConfig';
 
-export const useMarketCurrencies = (args: UseMarketCurrenciesArgs) => {
-	const config = useConfig();
-	return useQuery(currenciesOptions(args, config));
-};
+export type UseMarketCurrenciesParams = Optional<
+	MarketCurrenciesQueryOptions,
+	'config'
+>;
+
+/**
+ * Hook to fetch supported currencies for a marketplace
+ *
+ * Retrieves the list of currencies supported by the marketplace for a specific chain.
+ * Can optionally filter to exclude native currency or filter by collection.
+ *
+ * @param params - Configuration parameters
+ * @param params.chainId - The chain ID (must be number, e.g., 1 for Ethereum, 137 for Polygon)
+ * @param params.includeNativeCurrency - Whether to include native currency (default: true)
+ * @param params.collectionAddress - Optional collection address to filter currencies
+ * @param params.query - Optional React Query configuration
+ *
+ * @returns Query result containing supported currencies
+ *
+ * @example
+ * Basic usage:
+ * ```typescript
+ * const { data, isLoading } = useMarketCurrencies({
+ *   chainId: 137
+ * })
+ * ```
+ *
+ * @example
+ * Exclude native currency:
+ * ```typescript
+ * const { data, isLoading } = useMarketCurrencies({
+ *   chainId: 1,
+ *   includeNativeCurrency: false
+ * })
+ * ```
+ */
+export function useMarketCurrencies(params: UseMarketCurrenciesParams) {
+	const defaultConfig = useConfig();
+
+	const { config = defaultConfig, ...rest } = params;
+
+	const queryOptions = marketCurrenciesQueryOptions({
+		config,
+		...rest,
+	});
+
+	return useQuery({
+		...queryOptions,
+	});
+}
+
+export { marketCurrenciesQueryOptions };
+
+export type { FetchMarketCurrenciesParams, MarketCurrenciesQueryOptions };

package/src/react/hooks/useOpenConnectModal.tsx

@@ -0,0 +1,9 @@
+import { useConfig } from './useConfig';
+
+export const useOpenConnectModal = () => {
+	const context = useConfig();
+
+	return {
+		openConnectModal: context.openConnectModal,
+	};
+};

package/src/react/hooks/useRoyalty.tsx

@@ -1,18 +1,62 @@
+'use client';
+
+import type { Address } from 'viem';
 import { useReadContract } from 'wagmi';
-import { z } from 'zod';
 import { EIP2981_ABI } from '../../utils';
-import { AddressSchema, QueryArgSchema, collectableKeys } from '../_internal';
-
-const UseRoyaltySchema = z.object({
-	chainId: z.number(),
-	collectionAddress: AddressSchema,
-	collectibleId: z.string(),
-	query: QueryArgSchema.optional(),
-});
+import type { QueryArg } from '../_internal';
+import { collectableKeys } from '../_internal';
 
-type UseRoyaltyArgs = z.infer<typeof UseRoyaltySchema>;
+export interface UseRoyaltyArgs {
+	chainId: number;
+	collectionAddress: Address;
+	collectibleId: string;
+	query?: QueryArg;
+}
 
-export const useRoyalty = (args: UseRoyaltyArgs) => {
+/**
+ * Hook to fetch royalty information for a collectible
+ *
+ * Reads royalty information from the blockchain using the EIP-2981 standard.
+ * This hook queries the contract directly to get royalty percentage and recipient
+ * address for a specific token.
+ *
+ * @param args - Configuration parameters
+ * @param args.chainId - The chain ID (must be number, e.g., 1 for Ethereum, 137 for Polygon)
+ * @param args.collectionAddress - The collection contract address
+ * @param args.collectibleId - The token ID within the collection
+ * @param args.query - Optional React Query configuration
+ *
+ * @returns Query result containing royalty information (percentage and recipient) or null
+ *
+ * @example
+ * Basic usage:
+ * ```typescript
+ * const { data, isLoading } = useRoyalty({
+ *   chainId: 137,
+ *   collectionAddress: '0x...',
+ *   collectibleId: '1'
+ * })
+ *
+ * if (data) {
+ *   console.log('Royalty:', data.percentage, 'Recipient:', data.recipient)
+ * }
+ * ```
+ *
+ * @example
+ * With custom query options:
+ * ```typescript
+ * const { data, isLoading } = useRoyalty({
+ *   chainId: 1,
+ *   collectionAddress: '0x...',
+ *   collectibleId: '42',
+ *   query: {
+ *     refetchInterval: 60000,
+ *     enabled: hasTokenId
+ *   }
+ * })
+ * ```
+ */
+export function useRoyalty(args: UseRoyaltyArgs) {
 	const { chainId, collectionAddress, collectibleId, query } = args;
 	const scopeKey = `${collectableKeys.royaltyPercentage.join('.')}-${chainId}-${collectionAddress}-${collectibleId}`;
 
@@ -31,7 +75,7 @@ export const useRoyalty = (args: UseRoyaltyArgs) => {
 		recipient && percentage
 			? {
 					percentage,
-					recipient,
+					recipient: recipient as Address,
 				}
 			: null;
 
@@ -39,4 +83,4 @@ export const useRoyalty = (args: UseRoyaltyArgs) => {
 		...contractResult,
 		data: formattedData,
 	};
-};
+}

package/src/react/hooks/useShopCollectibleSaleData.tsx

@@ -0,0 +1,349 @@
+import { useMemo } from 'react';
+
+import type { Address } from 'viem';
+import { useReadContract } from 'wagmi';
+import {
+	ERC721_ABI,
+	ERC721_SALE_ABI,
+	ERC1155_SALES_CONTRACT_ABI,
+	SEQUENCE_1155_ITEMS_ABI,
+} from '../../utils';
+import { ContractType } from '../_internal';
+
+interface ShopCollectibleSaleData {
+	salePrice: { amount: string; currencyAddress: Address } | null;
+	paymentToken: Address | null;
+	supplyCap: string;
+	totalMinted: string;
+	quantityRemaining: string;
+	startTime: number | null;
+	endTime: number | null;
+	isActive: boolean;
+	isLoading: boolean;
+	error: Error | null;
+	isAvailable: boolean;
+}
+
+interface BaseShopCollectibleSaleDataProps {
+	chainId: number;
+	salesContractAddress: Address;
+	itemsContractAddress: Address;
+	enabled?: boolean;
+}
+
+interface ERC721ShopCollectibleSaleDataProps
+	extends BaseShopCollectibleSaleDataProps {
+	collectionType: ContractType.ERC721;
+	tokenId?: string;
+}
+
+interface ERC1155ShopCollectibleSaleDataProps
+	extends BaseShopCollectibleSaleDataProps {
+	collectionType: ContractType.ERC1155;
+	tokenId: string;
+}
+
+type UseShopCollectibleSaleDataProps =
+	| ERC721ShopCollectibleSaleDataProps
+	| ERC1155ShopCollectibleSaleDataProps;
+
+export function useShopCollectibleSaleData({
+	chainId,
+	salesContractAddress,
+	itemsContractAddress,
+	tokenId,
+	collectionType,
+	enabled = true,
+}: UseShopCollectibleSaleDataProps): ShopCollectibleSaleData {
+	// ERC721 Sales Contract Calls
+	const {
+		data: erc721SaleDetails,
+		isLoading: erc721SaleLoading,
+		error: erc721SaleError,
+	} = useReadContract({
+		chainId,
+		address: salesContractAddress,
+		abi: ERC721_SALE_ABI,
+		functionName: 'saleDetails',
+		query: {
+			enabled: enabled && collectionType === ContractType.ERC721,
+		},
+	});
+
+	const {
+		data: erc721TotalSupply,
+		isLoading: erc721SupplyLoading,
+		error: erc721SupplyError,
+	} = useReadContract({
+		chainId,
+		address: itemsContractAddress,
+		abi: ERC721_ABI,
+		functionName: 'totalSupply',
+		query: {
+			enabled: enabled && collectionType === ContractType.ERC721,
+		},
+	});
+
+	// ERC1155 Sales Contract Calls
+	const {
+		data: erc1155TokenSaleDetails,
+		isLoading: erc1155TokenSaleLoading,
+		error: erc1155TokenSaleError,
+	} = useReadContract({
+		chainId,
+		address: salesContractAddress,
+		abi: ERC1155_SALES_CONTRACT_ABI,
+		functionName: 'tokenSaleDetails',
+		args:
+			collectionType === ContractType.ERC1155 ? [BigInt(tokenId)] : undefined,
+		query: {
+			enabled: enabled && collectionType === ContractType.ERC1155,
+		},
+	});
+
+	const {
+		data: erc1155GlobalSaleDetails,
+		isLoading: erc1155GlobalSaleLoading,
+		error: erc1155GlobalSaleError,
+	} = useReadContract({
+		chainId,
+		address: salesContractAddress,
+		abi: ERC1155_SALES_CONTRACT_ABI,
+		functionName: 'globalSaleDetails',
+		query: {
+			enabled: enabled && collectionType === ContractType.ERC1155,
+		},
+	});
+
+	const {
+		data: erc1155PaymentToken,
+		isLoading: erc1155PaymentTokenLoading,
+		error: erc1155PaymentTokenError,
+	} = useReadContract({
+		chainId,
+		address: salesContractAddress,
+		abi: ERC1155_SALES_CONTRACT_ABI,
+		functionName: 'paymentToken',
+		query: {
+			enabled: enabled && collectionType === ContractType.ERC1155,
+		},
+	});
+
+	const {
+		data: erc1155TotalSupply,
+		isLoading: erc1155SupplyLoading,
+		error: erc1155SupplyError,
+	} = useReadContract({
+		chainId,
+		address: itemsContractAddress,
+		abi: SEQUENCE_1155_ITEMS_ABI,
+		functionName: 'totalSupply',
+		query: {
+			enabled: enabled && collectionType === ContractType.ERC1155,
+		},
+	});
+
+	return useMemo(() => {
+		const isLoading =
+			collectionType === ContractType.ERC721
+				? erc721SaleLoading || erc721SupplyLoading
+				: erc1155TokenSaleLoading ||
+					erc1155GlobalSaleLoading ||
+					erc1155PaymentTokenLoading ||
+					erc1155SupplyLoading;
+
+		const error =
+			collectionType === ContractType.ERC721
+				? erc721SaleError || erc721SupplyError
+				: erc1155TokenSaleError ||
+					erc1155GlobalSaleError ||
+					erc1155PaymentTokenError ||
+					erc1155SupplyError;
+
+		if (isLoading) {
+			return {
+				salePrice: null,
+				paymentToken: null,
+				supplyCap: '0',
+				totalMinted: '0',
+				quantityRemaining: '0',
+				startTime: null,
+				endTime: null,
+				isActive: false,
+				isLoading: true,
+				error: null,
+				isAvailable: false,
+			};
+		}
+
+		if (error) {
+			return {
+				salePrice: null,
+				paymentToken: null,
+				supplyCap: '0',
+				totalMinted: '0',
+				quantityRemaining: '0',
+				startTime: null,
+				endTime: null,
+				isActive: false,
+				isLoading: false,
+				error: error as Error,
+				isAvailable: false,
+			};
+		}
+
+		if (
+			collectionType === ContractType.ERC721 &&
+			erc721SaleDetails &&
+			erc721TotalSupply !== undefined
+		) {
+			const saleDetails = erc721SaleDetails as {
+				supplyCap: bigint;
+				cost: bigint;
+				paymentToken: Address;
+				startTime: bigint;
+				endTime: bigint;
+				merkleRoot: string;
+			};
+
+			const supplyCap = saleDetails.supplyCap.toString();
+			const totalMinted = erc721TotalSupply.toString();
+			const quantityRemaining = (
+				saleDetails.supplyCap - erc721TotalSupply
+			).toString();
+
+			const now = Math.floor(Date.now() / 1000);
+			const startTime = Number(saleDetails.startTime);
+			const endTime = Number(saleDetails.endTime);
+			const isActive = now >= startTime && now <= endTime;
+
+			return {
+				salePrice: {
+					amount: saleDetails.cost.toString(),
+					currencyAddress: saleDetails.paymentToken,
+				},
+				paymentToken: saleDetails.paymentToken,
+				supplyCap,
+				totalMinted,
+				quantityRemaining,
+				startTime,
+				endTime,
+				isActive,
+				isLoading: false,
+				error: null,
+				isAvailable: BigInt(quantityRemaining) > 0 && isActive,
+			};
+		}
+
+		if (
+			collectionType === ContractType.ERC1155 &&
+			erc1155PaymentToken &&
+			erc1155TotalSupply !== undefined &&
+			(erc1155TokenSaleDetails || erc1155GlobalSaleDetails)
+		) {
+			// Type the sale details structures
+			type SaleDetails = {
+				cost: bigint;
+				supplyCap: bigint;
+				startTime: bigint;
+				endTime: bigint;
+				merkleRoot: string;
+			};
+
+			const tokenSaleDetails = erc1155TokenSaleDetails as
+				| SaleDetails
+				| undefined;
+			const globalSaleDetails = erc1155GlobalSaleDetails as
+				| SaleDetails
+				| undefined;
+
+			// If token-specific details have zero values, use global as fallback
+			const useGlobal = tokenSaleDetails && tokenSaleDetails.supplyCap === 0n;
+			const finalSaleDetails = useGlobal
+				? globalSaleDetails
+				: tokenSaleDetails || globalSaleDetails;
+
+			if (!finalSaleDetails) {
+				return {
+					salePrice: null,
+					paymentToken: null,
+					supplyCap: '0',
+					totalMinted: '0',
+					quantityRemaining: '0',
+					startTime: null,
+					endTime: null,
+					isActive: false,
+					isLoading: false,
+					error: null,
+					isAvailable: false,
+				};
+			}
+
+			const supplyCap = finalSaleDetails.supplyCap.toString();
+			const totalMintedBigInt = erc1155TotalSupply
+				? BigInt(erc1155TotalSupply as bigint)
+				: 0n;
+			const totalMinted = totalMintedBigInt.toString();
+			const quantityRemaining = (
+				finalSaleDetails.supplyCap - totalMintedBigInt
+			).toString();
+
+			const now = Math.floor(Date.now() / 1000);
+			const startTime = Number(finalSaleDetails.startTime);
+			const endTime = Number(finalSaleDetails.endTime);
+			const isActive = now >= startTime && now <= endTime;
+
+			return {
+				salePrice: {
+					amount: finalSaleDetails.cost.toString(),
+					currencyAddress: erc1155PaymentToken,
+				},
+				paymentToken: erc1155PaymentToken,
+				supplyCap,
+				totalMinted,
+				quantityRemaining,
+				startTime,
+				endTime,
+				isActive,
+				isLoading: false,
+				error: null,
+				isAvailable: BigInt(quantityRemaining) > 0 && isActive,
+			};
+		}
+
+		// No valid data found
+		return {
+			salePrice: null,
+			paymentToken: null,
+			supplyCap: '0',
+			totalMinted: '0',
+			quantityRemaining: '0',
+			startTime: null,
+			endTime: null,
+			isActive: false,
+			isLoading: false,
+			error: null,
+			isAvailable: false,
+		};
+	}, [
+		collectionType,
+		erc721SaleDetails,
+		erc721TotalSupply,
+		erc721SaleLoading,
+		erc721SupplyLoading,
+		erc721SaleError,
+		erc721SupplyError,
+		erc1155TokenSaleDetails,
+		erc1155GlobalSaleDetails,
+		erc1155PaymentToken,
+		erc1155TotalSupply,
+		erc1155TokenSaleLoading,
+		erc1155GlobalSaleLoading,
+		erc1155PaymentTokenLoading,
+		erc1155SupplyLoading,
+		erc1155TokenSaleError,
+		erc1155GlobalSaleError,
+		erc1155PaymentTokenError,
+		erc1155SupplyError,
+	]);
+}

package/src/react/hooks/useTokenSaleDetailsBatch.tsx

@@ -62,15 +62,11 @@ export function useTokenSaleDetailsBatch({
 			const supplies = await Promise.all(
 				tokenIds.map(async (tokenId) => {
 					try {
-						const result = await indexerClient.getTokenSuppliesMap({
-							tokenMap: {
-								[collectionAddress]: [tokenId],
-							},
+						const result = await indexerClient.getTokenSupplies({
+							contractAddress: collectionAddress,
 							includeMetadata: false,
 						});
-						const supply = result.supplies?.[collectionAddress]?.find(
-							(s) => s.tokenID === tokenId,
-						);
+						const supply = result.tokenIDs?.find((s) => s.tokenID === tokenId);
 						return {
 							tokenId,
 							supply: supply ? Number(supply.supply) : 0,