@0xsequence/marketplace-sdk 0.8.12 → 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/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,
+	});
+}

package/src/react/queries/collectionDetails.ts

@@ -0,0 +1,64 @@
+import { queryOptions } from '@tanstack/react-query';
+import type { SdkConfig } from '../../types';
+import { getMarketplaceClient, type ValuesOptional } from '../_internal';
+import type { GetCollectionDetailArgs } from '../_internal/api/marketplace.gen';
+import { collectionKeys } from '../_internal/api/query-keys';
+import type { StandardQueryOptions } from '../types/query';
+
+export interface FetchCollectionDetailsParams
+	extends Omit<GetCollectionDetailArgs, 'chainId' | 'contractAddress'> {
+	chainId: number;
+	collectionAddress: string;
+	config: SdkConfig;
+}
+
+/**
+ * Fetches collection details from the marketplace API
+ */
+export async function fetchCollectionDetails(
+	params: FetchCollectionDetailsParams,
+) {
+	const { collectionAddress, chainId, config, ...additionalApiParams } = params;
+
+	const marketplaceClient = getMarketplaceClient(config);
+
+	const apiArgs: GetCollectionDetailArgs = {
+		contractAddress: collectionAddress,
+		chainId: String(chainId),
+		...additionalApiParams,
+	};
+
+	const result = await marketplaceClient.getCollectionDetail(apiArgs);
+	return result.collection;
+}
+
+export type CollectionDetailsQueryOptions =
+	ValuesOptional<FetchCollectionDetailsParams> & {
+		query?: StandardQueryOptions;
+	};
+
+export function collectionDetailsQueryOptions(
+	params: CollectionDetailsQueryOptions,
+) {
+	const enabled = Boolean(
+		params.collectionAddress &&
+			params.chainId &&
+			params.config &&
+			(params.query?.enabled ?? true),
+	);
+
+	return queryOptions({
+		queryKey: [...collectionKeys.detail, params],
+		queryFn: () =>
+			fetchCollectionDetails({
+				// 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,
+	});
+}

package/src/react/queries/countListingsForCollectible.ts

@@ -0,0 +1,73 @@
+import { queryOptions } from '@tanstack/react-query';
+import type { SdkConfig } from '../../types';
+import { getMarketplaceClient, type ValuesOptional } from '../_internal';
+import type {
+	GetCountOfListingsForCollectibleArgs,
+	OrderFilter,
+} from '../_internal/api/marketplace.gen';
+import { collectableKeys } from '../_internal/api/query-keys';
+import type { StandardQueryOptions } from '../types/query';
+
+export interface FetchCountListingsForCollectibleParams {
+	chainId: number;
+	collectionAddress: string;
+	collectibleId: string;
+	config: SdkConfig;
+	filter?: OrderFilter;
+}
+
+/**
+ * Fetches count of listings for a collectible from the marketplace API
+ */
+export async function fetchCountListingsForCollectible(
+	params: FetchCountListingsForCollectibleParams,
+) {
+	const { collectionAddress, chainId, collectibleId, config, filter } = params;
+
+	const client = getMarketplaceClient(config);
+
+	const apiArgs: GetCountOfListingsForCollectibleArgs = {
+		contractAddress: collectionAddress,
+		chainId: String(chainId),
+		tokenId: collectibleId,
+		filter,
+	};
+
+	const result = await client.getCountOfListingsForCollectible(apiArgs);
+	return result.count;
+}
+
+export type CountListingsForCollectibleQueryOptions =
+	ValuesOptional<FetchCountListingsForCollectibleParams> & {
+		query?: StandardQueryOptions;
+	};
+
+export function countListingsForCollectibleQueryOptions(
+	params: CountListingsForCollectibleQueryOptions,
+) {
+	const enabled = Boolean(
+		params.collectionAddress &&
+			params.chainId &&
+			params.collectibleId &&
+			params.config &&
+			(params.query?.enabled ?? true),
+	);
+
+	return queryOptions({
+		queryKey: [...collectableKeys.listingsCount, params],
+		queryFn: () =>
+			fetchCountListingsForCollectible({
+				// 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!,
+				filter: params.filter,
+			}),
+		...params.query,
+		enabled,
+	});
+}