@0xsequence/marketplace-sdk 0.8.11 → 0.9.0

package/src/react/hooks/useGetTokenSuppliesMap.tsx

@@ -0,0 +1,73 @@
+'use client';
+
+import { useQuery } from '@tanstack/react-query';
+import type { Optional } from '../_internal';
+import {
+	type FetchGetTokenSuppliesMapParams,
+	type GetTokenSuppliesMapQueryOptions,
+	getTokenSuppliesMapQueryOptions,
+} from '../queries/getTokenSuppliesMap';
+import { useConfig } from './useConfig';
+
+export type UseGetTokenSuppliesMapParams = Optional<
+	GetTokenSuppliesMapQueryOptions,
+	'config'
+>;
+
+/**
+ * Hook to fetch token supplies mapping from the indexer
+ *
+ * Retrieves supply information for multiple tokens within a collection using the indexer API.
+ * This is useful for getting supply data for batches of tokens efficiently.
+ *
+ * @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.tokenIds - Array of token IDs to fetch supplies for
+ * @param params.config - Optional SDK configuration (defaults from context)
+ * @param params.query - Optional React Query configuration
+ *
+ * @returns Query result containing token supplies mapping
+ *
+ * @example
+ * Basic usage:
+ * ```typescript
+ * const { data: suppliesMap, isLoading } = useGetTokenSuppliesMap({
+ *   chainId: 137,
+ *   collectionAddress: '0x...',
+ *   tokenIds: ['1', '2', '3']
+ * })
+ * ```
+ *
+ * @example
+ * With query options:
+ * ```typescript
+ * const { data: suppliesMap } = useGetTokenSuppliesMap({
+ *   chainId: 1,
+ *   collectionAddress: '0x...',
+ *   tokenIds: selectedTokenIds,
+ *   query: {
+ *     enabled: selectedTokenIds.length > 0,
+ *     staleTime: 30 * 1000 // 30 seconds
+ *   }
+ * })
+ * ```
+ */
+export function useGetTokenSuppliesMap(params: UseGetTokenSuppliesMapParams) {
+	const defaultConfig = useConfig();
+
+	const { config = defaultConfig, ...rest } = params;
+
+	const queryOptions = getTokenSuppliesMapQueryOptions({
+		config,
+		...rest,
+	});
+
+	return useQuery({
+		...queryOptions,
+	});
+}
+
+export { getTokenSuppliesMapQueryOptions };
+
+export type { FetchGetTokenSuppliesMapParams, GetTokenSuppliesMapQueryOptions };

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,16 +1,18 @@
 import { useInfiniteQuery } from '@tanstack/react-query';
-import { ContractType } from '../../types/api-types';
-import { type UseInventoryArgs, inventoryOptions } from '../queries/inventory';
+import { ContractType } from '../_internal';
+import { inventoryOptions, type UseInventoryArgs } from '../queries/inventory';
 import { useConfig } from './useConfig';
 import { useMarketplaceConfig } from './useMarketplaceConfig';
 
 export function useInventory(args: UseInventoryArgs) {
 	const config = useConfig();
-	const marketplaceConfig = useMarketplaceConfig();
+	const { data: marketplaceConfig } = useMarketplaceConfig();
+
 	const isLaos721 =
-		marketplaceConfig.data?.market.collections.find(
-			(c) => c.itemsAddress === args.collectionAddress,
-		)?.contractType === ContractType.LAOSERC721;
+		marketplaceConfig?.market?.collections?.find(
+			(c) =>
+				c.itemsAddress === args.collectionAddress && c.chainId === args.chainId,
+		)?.contractType === ContractType.LAOS_ERC_721;
 
 	return useInfiniteQuery(inventoryOptions({ ...args, isLaos721 }, config));
 }

package/src/react/hooks/useList1155ShopCardData.tsx

@@ -0,0 +1,103 @@
+import type { Address } from 'viem';
+import { useReadContract } from 'wagmi';
+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[];
+	chainId: number;
+	contractAddress: Address;
+	salesContractAddress: Address;
+	enabled?: boolean;
+}
+
+export function useList1155ShopCardData({
+	tokenIds,
+	chainId,
+	contractAddress,
+	salesContractAddress,
+	enabled = true,
+}: UseList1155ShopCardDataProps) {
+	const { showListedOnly } = useFilterState();
+	const {
+		data: primarySaleItems,
+		isLoading: primarySaleItemsLoading,
+		error: primarySaleItemsError,
+	} = useListPrimarySaleItems({
+		chainId,
+		primarySaleContractAddress: salesContractAddress,
+		filter: {
+			includeEmpty: !showListedOnly,
+		},
+	});
+
+	const { data: collection, isLoading: collectionLoading } = useCollection({
+		chainId,
+		collectionAddress: contractAddress,
+	});
+
+	const { data: paymentToken, isLoading: paymentTokenLoading } =
+		useReadContract({
+			chainId,
+			address: salesContractAddress,
+			abi: ERC1155_SALES_CONTRACT_ABI,
+			functionName: 'paymentToken',
+			query: {
+				enabled,
+			},
+		});
+
+	const isLoading =
+		primarySaleItemsLoading || collectionLoading || paymentTokenLoading;
+
+	// Flatten all collectibles from all pages
+	const allPrimarySaleItems =
+		primarySaleItems?.pages.flatMap((page) => page.primarySaleItems) ?? [];
+
+	const collectibleCards = tokenIds.map((tokenId) => {
+		const matchingPrimarySaleItem = allPrimarySaleItems.find(
+			(item) => item.primarySaleItem.tokenId?.toString() === tokenId,
+		);
+
+		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();
+
+		return {
+			collectibleId: tokenId,
+			chainId,
+			collectionAddress: contractAddress,
+			collectionType: ContractType.ERC1155,
+			tokenMetadata: tokenMetadata,
+			cardLoading: isLoading,
+			salesContractAddress: salesContractAddress,
+			salePrice,
+			quantityInitial: supply,
+			quantityDecimals: collection?.decimals || 0,
+			quantityRemaining: supply,
+			saleStartsAt: saleData?.startDate?.toString(),
+			saleEndsAt: saleData?.endDate?.toString(),
+			marketplaceType: 'shop',
+		} satisfies ShopCollectibleCardProps;
+	});
+
+	return {
+		collectibleCards,
+		tokenMetadataError: primarySaleItemsError,
+		tokenSaleDetailsError: null,
+		isLoading,
+	};
+}

package/src/react/hooks/useList721ShopCardData.tsx

@@ -0,0 +1,160 @@
+import type { Address } from 'viem';
+import { useReadContract } from 'wagmi';
+import { ContractType, OrderSide, type TokenMetadata } from '../../types';
+import { ERC721_SALE_ABI } from '../../utils';
+import type { ShopCollectibleCardProps } from '../ui/components/marketplace-collectible-card/types';
+import { useFilterState } from './useFilterState';
+import { useListCollectibles } from './useListCollectibles';
+import { useListPrimarySaleItems } from './useListPrimarySaleItems';
+
+interface UseList721ShopCardDataProps {
+	tokenIds: string[];
+	chainId: number;
+	contractAddress: Address;
+	salesContractAddress: Address;
+	enabled?: boolean;
+}
+
+export function useList721ShopCardData({
+	tokenIds,
+	chainId,
+	contractAddress,
+	salesContractAddress,
+	enabled = true,
+}: UseList721ShopCardDataProps) {
+	const { showListedOnly } = useFilterState();
+
+	const {
+		data: primarySaleItems,
+		isLoading: primarySaleItemsLoading,
+		error: primarySaleItemsError,
+	} = useListPrimarySaleItems({
+		chainId,
+		primarySaleContractAddress: salesContractAddress,
+		filter: {
+			includeEmpty: !showListedOnly,
+		},
+	});
+
+	// Check if we have minted tokens by looking at the first available token ID
+	const firstAvailableTokenId =
+		primarySaleItems?.pages[0]?.primarySaleItems[0]?.primarySaleItem.tokenId?.toString();
+	const hasMintedTokens: boolean =
+		Boolean(firstAvailableTokenId) && Number(firstAvailableTokenId) > 0;
+
+	// Fetch metadata for minted tokens
+	const { data: mintedTokensMetadata, isLoading: mintedTokensMetadataLoading } =
+		useListCollectibles({
+			chainId,
+			collectionAddress: contractAddress,
+			side: OrderSide.listing,
+			filter: {
+				includeEmpty: true,
+			},
+			query: {
+				enabled: enabled && hasMintedTokens,
+			},
+		});
+
+	// For ERC721, we'll fetch the sale details directly from the contract
+	const {
+		data: saleDetails,
+		isLoading: saleDetailsLoading,
+		error: saleDetailsError,
+	} = useReadContract({
+		chainId,
+		address: salesContractAddress,
+		abi: ERC721_SALE_ABI,
+		functionName: 'saleDetails',
+		query: {
+			enabled,
+		},
+	});
+
+	const isLoading =
+		saleDetailsLoading ||
+		primarySaleItemsLoading ||
+		mintedTokensMetadataLoading;
+
+	// Create a map of token metadata from minted tokens
+	const mintedTokensMetadataMap = new Map<string, TokenMetadata>();
+	for (const page of mintedTokensMetadata?.pages ?? []) {
+		for (const collectible of page.collectibles) {
+			mintedTokensMetadataMap.set(
+				collectible.metadata.tokenId,
+				collectible.metadata,
+			);
+		}
+	}
+
+	const collectibleCards = tokenIds.map((tokenId) => {
+		const minted =
+			hasMintedTokens && Number(tokenId) < Number(firstAvailableTokenId);
+
+		const matchingPrimarySaleItem = primarySaleItems?.pages
+			.flatMap((page) => page.primarySaleItems)
+			.find(
+				(item: { primarySaleItem: { tokenId: { toString: () => string } } }) =>
+					item.primarySaleItem.tokenId?.toString() === tokenId,
+			);
+
+		const saleData = matchingPrimarySaleItem?.primarySaleItem;
+		let tokenMetadata = matchingPrimarySaleItem?.metadata;
+
+		// If token is minted, prefer metadata from mintedTokensMetadata
+		if (minted && mintedTokensMetadataMap.has(tokenId)) {
+			tokenMetadata = mintedTokensMetadataMap.get(tokenId);
+		}
+		// Fallback to empty metadata if none found
+		tokenMetadata = tokenMetadata || ({} as TokenMetadata);
+
+		const salePrice = saleData
+			? {
+					amount: saleData.priceAmount?.toString() || '',
+					currencyAddress: saleData.currencyAddress as Address,
+				}
+			: {
+					amount: saleDetails?.cost?.toString() || '',
+					currencyAddress: saleDetails?.paymentToken ?? ('0x' as Address),
+				};
+
+		const quantityInitial =
+			saleData?.supply?.toString() ??
+			(saleDetails?.supplyCap ? saleDetails.supplyCap.toString() : undefined);
+
+		const quantityRemaining = minted ? undefined : '1';
+
+		const saleStartsAt =
+			saleData?.startDate?.toString() ?? saleDetails?.startTime?.toString();
+
+		const saleEndsAt =
+			saleData?.endDate?.toString() ?? saleDetails?.endTime?.toString();
+
+		return {
+			collectibleId: tokenId,
+			chainId,
+			collectionAddress: contractAddress,
+			collectionType: ContractType.ERC721,
+			tokenMetadata: tokenMetadata,
+			cardLoading: isLoading,
+			salesContractAddress: salesContractAddress,
+			salePrice,
+			quantityInitial,
+			quantityRemaining,
+			quantityDecimals: 0,
+			saleStartsAt,
+			saleEndsAt,
+			marketplaceType: 'shop',
+		} satisfies ShopCollectibleCardProps;
+	});
+
+	return {
+		salePrice: collectibleCards[0]?.salePrice,
+		collectibleCards,
+		saleDetailsError,
+		primarySaleItemsError,
+		saleDetails,
+		primarySaleItems,
+		isLoading,
+	};
+}

package/src/react/hooks/useListBalances.tsx

@@ -1,7 +1,7 @@
 import { useInfiniteQuery } from '@tanstack/react-query';
-import { ContractType } from '../../types/api-types';
-import { listBalancesOptions } from '../queries/listBalances';
+import { ContractType } from '../_internal';
 import type { UseListBalancesArgs } from '../queries/listBalances';
+import { listBalancesOptions } from '../queries/listBalances';
 import { useConfig } from './useConfig';
 import { useMarketplaceConfig } from './useMarketplaceConfig';
 
@@ -29,13 +29,10 @@ export function useListBalances(args: UseListBalancesArgs) {
 	const { data: marketplaceConfig } = useMarketplaceConfig();
 
 	const isLaos721 =
-		marketplaceConfig?.market.collections.find(
-			(collection) => collection.itemsAddress === args.contractAddress,
-		)?.contractType === ContractType.LAOSERC721;
-
-	if (isLaos721) {
-		args.isLaos721 = true;
-	}
+		marketplaceConfig?.market?.collections?.find(
+			(c) =>
+				c.itemsAddress === args.contractAddress && c.chainId === args.chainId,
+		)?.contractType === ContractType.LAOS_ERC_721;
 
-	return useInfiniteQuery(listBalancesOptions(args, config));
+	return useInfiniteQuery(listBalancesOptions({ ...args, isLaos721 }, config));
 }

package/src/react/hooks/useListCollectibleActivities.tsx

@@ -1,58 +1,98 @@
-import { queryOptions, useQuery } from '@tanstack/react-query';
-import type { z } from 'zod';
-import type { SdkConfig } from '../../types';
-import { collectableKeys, getMarketplaceClient } from '../_internal';
-import type {
-	getListCollectibleActivitiesArgsSchema,
-	getListCollectibleActivitiesReturnSchema,
-} from '../_internal/api/zod-schema';
+'use client';
+
+import { useQuery } from '@tanstack/react-query';
+import type { Optional } from '../_internal';
+import {
+	type FetchListCollectibleActivitiesParams,
+	type fetchListCollectibleActivities,
+	type ListCollectibleActivitiesQueryOptions,
+	listCollectibleActivitiesQueryOptions,
+} from '../queries/listCollectibleActivities';
 import { useConfig } from './useConfig';
 
-export type UseListCollectibleActivitiesArgs = z.infer<
-	typeof getListCollectibleActivitiesArgsSchema
+export type UseListCollectibleActivitiesParams = Optional<
+	ListCollectibleActivitiesQueryOptions,
+	'config'
 >;
 
-export type UseListCollectibleActivitiesReturn = z.infer<
-	typeof getListCollectibleActivitiesReturnSchema
->;
+/**
+ * Hook to fetch a list of activities for a specific collectible
+ *
+ * Fetches activities (transfers, sales, offers, etc.) for a specific token
+ * from the marketplace with support for pagination and sorting.
+ *
+ * @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 specific token ID to fetch activities for
+ * @param params.page - Page number to fetch (default: 1)
+ * @param params.pageSize - Number of activities per page (default: 10)
+ * @param params.sort - Sort order for activities
+ * @param params.query - Optional React Query configuration
+ *
+ * @returns Query result containing activities data
+ *
+ * @example
+ * Basic usage:
+ * ```typescript
+ * const { data, isLoading } = useListCollectibleActivities({
+ *   chainId: 137,
+ *   collectionAddress: '0x...',
+ *   tokenId: '123'
+ * })
+ * ```
+ *
+ * @example
+ * With pagination:
+ * ```typescript
+ * const { data } = useListCollectibleActivities({
+ *   chainId: 1,
+ *   collectionAddress: '0x...',
+ *   tokenId: '456',
+ *   page: 2,
+ *   pageSize: 20
+ * })
+ * ```
+ *
+ * @example
+ * With sorting:
+ * ```typescript
+ * const { data } = useListCollectibleActivities({
+ *   chainId: 137,
+ *   collectionAddress: '0x...',
+ *   tokenId: '789',
+ *   sort: 'timestamp_desc',
+ *   pageSize: 50
+ * })
+ * ```
+ */
+export function useListCollectibleActivities(
+	params: UseListCollectibleActivitiesParams,
+) {
+	const defaultConfig = useConfig();
 
-const fetchCollectibleActivities = async (
-	args: UseListCollectibleActivitiesArgs,
-	config: SdkConfig,
-) => {
-	const marketplaceClient = getMarketplaceClient(args.chainId, config);
-	return marketplaceClient
-		.listCollectibleActivities({
-			contractAddress: args.collectionAddress,
-			tokenId: args.tokenId,
-			page: args.query?.enabled
-				? {
-						page: args.query.page ?? 1,
-						pageSize: args.query.pageSize ?? 10,
-						sort: args.query.sort,
-					}
-				: undefined,
-		})
-		.then((data) => ({
-			activities: data.activities,
-			page: data.page,
-		}));
-};
+	const { config = defaultConfig, ...rest } = params;
 
-export const listCollectibleActivitiesOptions = (
-	args: UseListCollectibleActivitiesArgs,
-	config: SdkConfig,
-) => {
-	return queryOptions({
-		queryKey: [...collectableKeys.collectibleActivities, args, config],
-		queryFn: () => fetchCollectibleActivities(args, config),
-		enabled: args.query?.enabled ?? true,
+	const queryOptions = listCollectibleActivitiesQueryOptions({
+		config,
+		...rest,
 	});
-};
 
-export const useListCollectibleActivities = (
-	args: UseListCollectibleActivitiesArgs,
-) => {
-	const config = useConfig();
-	return useQuery(listCollectibleActivitiesOptions(args, config));
+	return useQuery({
+		...queryOptions,
+	});
+}
+
+export { listCollectibleActivitiesQueryOptions };
+
+export type {
+	FetchListCollectibleActivitiesParams,
+	ListCollectibleActivitiesQueryOptions,
 };
+
+// Legacy exports for backward compatibility during migration
+export type UseListCollectibleActivitiesArgs =
+	UseListCollectibleActivitiesParams;
+export type UseListCollectibleActivitiesReturn = Awaited<
+	ReturnType<typeof fetchListCollectibleActivities>
+>;