@0xsequence/marketplace-sdk 0.8.11 → 0.9.0

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

@@ -0,0 +1,134 @@
+import { useQuery } from '@tanstack/react-query';
+import { getUnixTime } from 'date-fns';
+import type { Address } from 'viem';
+import { useReadContracts } from 'wagmi';
+import { ERC1155_SALES_CONTRACT_ABI } from '../..';
+import { getIndexerClient } from '../_internal';
+import { useConfig } from './useConfig';
+
+interface useTokenSaleDetailsBatch {
+	tokenIds: string[];
+	salesContractAddress: Address;
+	collectionAddress: Address;
+	chainId: number;
+	query?: {
+		enabled?: boolean;
+	};
+}
+
+export function useTokenSaleDetailsBatch({
+	tokenIds,
+	salesContractAddress,
+	chainId,
+	collectionAddress,
+	query,
+}: useTokenSaleDetailsBatch) {
+	const config = useConfig();
+	const indexerClient = getIndexerClient(chainId, config);
+
+	const getReadContractsArgs = (tokenIds: string[]) =>
+		tokenIds.map((tokenId) => ({
+			address: salesContractAddress,
+			abi: ERC1155_SALES_CONTRACT_ABI,
+			functionName: 'tokenSaleDetails',
+			args: [tokenId],
+			chainId,
+		}));
+
+	const {
+		data: tokenSaleDetails,
+		isLoading: tokenSaleDetailsLoading,
+		error: tokenSaleDetailsError,
+	} = useReadContracts({
+		batchSize: 500_000, // Node gateway limit has a limit of 512kB, setting it to 500kB to be safe
+		contracts: getReadContractsArgs(tokenIds),
+		query: {
+			enabled: query?.enabled,
+		},
+	});
+
+	// Query token supplies individually using the indexer client:
+	/*
+	This way, if token 4 isn't minted, we can still get the supply information for tokens 0-3, and just treat token 4's supply as 0 (unminted). 
+	The problem is essentially that one unminted token was poisoning the entire response when querying all tokens at once.
+	*/
+	const {
+		data: tokenSupplies,
+		isLoading: tokenSuppliesLoading,
+		error: tokenSuppliesError,
+	} = useQuery({
+		queryKey: ['token-supplies-batch', chainId, collectionAddress, tokenIds],
+		queryFn: async () => {
+			const supplies = await Promise.all(
+				tokenIds.map(async (tokenId) => {
+					try {
+						const result = await indexerClient.getTokenSuppliesMap({
+							tokenMap: {
+								[collectionAddress]: [tokenId],
+							},
+							includeMetadata: false,
+						});
+						const supply = result.supplies?.[collectionAddress]?.find(
+							(s) => s.tokenID === tokenId,
+						);
+						return {
+							tokenId,
+							supply: supply ? Number(supply.supply) : 0,
+							error: null,
+						};
+					} catch (error) {
+						return {
+							tokenId,
+							supply: 0,
+							error,
+						};
+					}
+				}),
+			);
+			return supplies;
+		},
+		enabled: query?.enabled,
+	});
+
+	const extendedSupplyData = (tokenSaleDetails || [])
+		.map((data, index) => ({
+			...data,
+			tokenId: tokenIds[index],
+		}))
+		.filter((data) => data.status === 'success')
+		.filter((data) => {
+			if (typeof data.result !== 'object') return false;
+			const now = BigInt(getUnixTime(new Date()));
+			return data.result.endTime > now && data.result.startTime < now;
+		});
+
+	const getInitialSupply = (tokenId: string): number | undefined => {
+		const found = extendedSupplyData.find((data) => data.tokenId === tokenId);
+		if (!found || typeof found.result !== 'object' || found.result === null)
+			return undefined;
+		const supply = found.result.supplyCap;
+		if (supply === undefined) return undefined;
+		// https://github.com/0xsequence/contracts-library/blob/ead1baf34270c76260d01cfc130bb7cc9d57518e/src/tokens/ERC1155/utility/sale/IERC1155Sale.sol#L8
+		// 0 means infinite
+		if (supply === 0n) return Number.POSITIVE_INFINITY;
+		return Number(supply);
+	};
+
+	const getRemainingSupply = (tokenId: string): number | undefined => {
+		const initialSupply = getInitialSupply(tokenId);
+		if (!initialSupply) return undefined;
+
+		const supplyData = tokenSupplies?.find((s) => s.tokenId === tokenId);
+		if (!supplyData || supplyData.error) return initialSupply; // If no supply data or error, assume nothing is minted
+
+		return initialSupply - supplyData.supply;
+	};
+
+	return {
+		extendedSupplyData,
+		getInitialSupply,
+		getRemainingSupply,
+		loading: tokenSuppliesLoading || tokenSaleDetailsLoading,
+		error: tokenSuppliesError || tokenSaleDetailsError,
+	};
+}

package/src/react/hooks/useTransferTokens.tsx

@@ -1,4 +1,4 @@
-import { type Abi, type Address, type Hex, erc721Abi } from 'viem';
+import { type Abi, type Address, erc721Abi, type Hex } from 'viem';
 import { useAccount, useWriteContract } from 'wagmi';
 import { ERC1155_ABI } from '../../utils';
 import { NoWalletConnectedError } from '../../utils/_internal/error/transaction';

package/src/react/hooks/util/optimisticCancelUpdates.ts

@@ -1,10 +1,10 @@
 import type { QueryClient } from '@tanstack/react-query';
 import {
+	collectableKeys,
 	type GetCountOfListingsForCollectibleReturn,
 	type GetCountOfOffersForCollectibleReturn,
 	type ListListingsForCollectibleReturn,
 	type ListOffersForCollectibleReturn,
-	collectableKeys,
 } from '../../_internal';
 
 const SECOND = 1000;
@@ -21,13 +21,11 @@ export const updateQueriesOnCancel = ({
 	queryClient.setQueriesData(
 		{ queryKey: collectableKeys.offersCount, exact: false },
 		(oldData: GetCountOfOffersForCollectibleReturn | undefined) => {
-			if (!oldData) return { count: 0 };
-			return { count: Math.max(0, oldData.count - 1) };
+			if (!oldData) return 0;
+			return Math.max(0, oldData.count - 1);
 		},
 	);
 
-	console.log('query client ', queryClient, 'orderId', orderId);
-
 	// remove the offer with matching orderId
 	queryClient.setQueriesData(
 		{ queryKey: collectableKeys.offers, exact: false },
@@ -51,8 +49,8 @@ export const updateQueriesOnCancel = ({
 	queryClient.setQueriesData(
 		{ queryKey: collectableKeys.listingsCount, exact: false },
 		(oldData: GetCountOfListingsForCollectibleReturn | undefined) => {
-			if (!oldData) return { count: 0 };
-			return { count: Math.max(0, oldData.count - 1) };
+			if (!oldData) return 0;
+			return Math.max(0, oldData.count - 1);
 		},
 	);
 

package/src/react/index.ts

@@ -1,6 +1,8 @@
-export * from './provider';
-export * from './hooks';
-export * from './hooks/options';
 export * from './_internal/api/get-query-client';
 export * from './_internal/wagmi/create-config';
+export * from './hooks';
+export * from './hooks/options';
+export * from './provider';
+export * from './queries';
+export * from './types/query';
 export * from './ui/index';

package/src/react/queries/balanceOfCollectible.ts

@@ -2,7 +2,7 @@ import { queryOptions, skipToken } from '@tanstack/react-query';
 import type { Hex } from 'viem';
 import type { UseQueryParameters } from 'wagmi/query';
 import type { SdkConfig } from '../../types';
-import { LaosAPI, collectableKeys, getIndexerClient } from '../_internal';
+import { collectableKeys, getIndexerClient, LaosAPI } from '../_internal';
 
 export type UseBalanceOfCollectibleArgs = {
 	collectionAddress: Hex;

package/src/react/queries/collectible.ts

@@ -0,0 +1,66 @@
+import type { GetTokenMetadataArgs } from '@0xsequence/metadata';
+import { queryOptions } from '@tanstack/react-query';
+import type { SdkConfig } from '../../types';
+import { getMetadataClient, type ValuesOptional } from '../_internal';
+import { collectableKeys } from '../_internal/api/query-keys';
+import type { StandardQueryOptions } from '../types/query';
+
+export interface FetchCollectibleParams
+	extends Omit<
+		GetTokenMetadataArgs,
+		'chainID' | 'contractAddress' | 'tokenIDs'
+	> {
+	chainId: number;
+	collectionAddress: string;
+	collectibleId: string;
+	config: SdkConfig;
+}
+
+/**
+ * Fetches collectible metadata from the metadata API
+ */
+export async function fetchCollectible(params: FetchCollectibleParams) {
+	const { collectionAddress, collectibleId, chainId, config } = params;
+
+	const metadataClient = getMetadataClient(config);
+
+	const apiArgs: GetTokenMetadataArgs = {
+		contractAddress: collectionAddress,
+		chainID: String(chainId),
+		tokenIDs: [collectibleId],
+	};
+
+	const result = await metadataClient.getTokenMetadata(apiArgs);
+	return result.tokenMetadata[0];
+}
+
+export type CollectibleQueryOptions = ValuesOptional<FetchCollectibleParams> & {
+	query?: StandardQueryOptions;
+};
+
+export function collectibleQueryOptions(params: CollectibleQueryOptions) {
+	const enabled = Boolean(
+		params.collectionAddress &&
+			params.collectibleId &&
+			params.chainId &&
+			params.config &&
+			(params.query?.enabled ?? true),
+	);
+
+	return queryOptions({
+		queryKey: [...collectableKeys.details, params],
+		queryFn: () =>
+			fetchCollectible({
+				// biome-ignore lint/style/noNonNullAssertion: The enabled check above ensures these are not undefined
+				chainId: params.chainId!,
+				// biome-ignore lint/style/noNonNullAssertion: The enabled check above ensures these are not undefined
+				collectionAddress: params.collectionAddress!,
+				// biome-ignore lint/style/noNonNullAssertion: The enabled check above ensures these are not undefined
+				collectibleId: params.collectibleId!,
+				// biome-ignore lint/style/noNonNullAssertion: The enabled check above ensures these are not undefined
+				config: params.config!,
+			}),
+		...params.query,
+		enabled,
+	});
+}

package/src/react/queries/collection.ts

@@ -0,0 +1,55 @@
+import { queryOptions } from '@tanstack/react-query';
+import type { SdkConfig } from '../../types';
+import { getMetadataClient, type ValuesOptional } from '../_internal';
+import { collectionKeys } from '../_internal/api/query-keys';
+import type { StandardQueryOptions } from '../types/query';
+
+export interface FetchCollectionParams {
+	chainId: number;
+	collectionAddress: string;
+	config: SdkConfig;
+}
+
+/**
+ * Fetches collection information from the metadata API
+ */
+export async function fetchCollection(params: FetchCollectionParams) {
+	const { collectionAddress, chainId, config } = params;
+
+	const metadataClient = getMetadataClient(config);
+
+	const result = await metadataClient.getContractInfo({
+		chainID: chainId.toString(),
+		contractAddress: collectionAddress,
+	});
+
+	return result.contractInfo;
+}
+
+export type CollectionQueryOptions = ValuesOptional<FetchCollectionParams> & {
+	query?: StandardQueryOptions;
+};
+
+export function collectionQueryOptions(params: CollectionQueryOptions) {
+	const enabled = Boolean(
+		params.collectionAddress &&
+			params.chainId &&
+			params.config &&
+			(params.query?.enabled ?? true),
+	);
+
+	return queryOptions({
+		queryKey: [...collectionKeys.detail, params],
+		queryFn: () =>
+			fetchCollection({
+				// biome-ignore lint/style/noNonNullAssertion: The enabled check above ensures these are not undefined
+				chainId: params.chainId!,
+				// biome-ignore lint/style/noNonNullAssertion: The enabled check above ensures these are not undefined
+				collectionAddress: params.collectionAddress!,
+				// biome-ignore lint/style/noNonNullAssertion: The enabled check above ensures these are not undefined
+				config: params.config!,
+			}),
+		...params.query,
+		enabled,
+	});
+}