@0xsequence/marketplace-sdk 0.8.11 → 0.8.12

package/src/react/hooks/useERC721SaleMintedTokens.tsx

@@ -0,0 +1,67 @@
+import type { Address } from 'viem';
+import { useReadContract } from 'wagmi';
+import { ERC721_SALE_ABI } from '../../../../sdk/src';
+import { useGetTokenSuppliesMap } from './useGetTokenSuppliesMap';
+
+interface UseERC721SaleMintedTokensProps {
+	chainId: number;
+	contractAddress: Address;
+	salesContractAddress: Address;
+	enabled?: boolean;
+	tokenIds: string[];
+}
+
+export function useERC721SaleMintedTokens({
+	chainId,
+	contractAddress,
+	salesContractAddress,
+	tokenIds,
+	enabled = true,
+}: UseERC721SaleMintedTokensProps) {
+	const {
+		data: saleDetails,
+		isLoading: saleDetailsLoading,
+		error: saleDetailsError,
+	} = useReadContract({
+		chainId,
+		address: salesContractAddress,
+		abi: ERC721_SALE_ABI,
+		functionName: 'saleDetails',
+		query: {
+			enabled,
+		},
+	});
+
+	// Get token supplies for all potential tokens in the sale
+	const { data: tokenSupplies, isLoading: tokenSuppliesLoading } =
+		useGetTokenSuppliesMap({
+			chainId,
+			tokenIds,
+			collectionAddress: contractAddress as Address,
+		});
+
+	const isLoading = saleDetailsLoading || tokenSuppliesLoading;
+
+	// Count how many tokens have been minted/owned
+	const ownedCount = tokenIds.reduce((count, tokenId) => {
+		const supplies = tokenSupplies?.supplies[contractAddress];
+		const supply = supplies?.find((s) => s.tokenID === tokenId);
+		// If supply exists and is greater than 0, token exists and is owned
+		const hasOwner = supply ? BigInt(supply.supply) > 0n : false;
+		return count + (hasOwner ? 1 : 0);
+	}, 0);
+
+	const totalSupplyCap = saleDetails?.supplyCap
+		? Number(saleDetails.supplyCap)
+		: 0;
+	const remainingCount = Math.max(0, totalSupplyCap - ownedCount);
+
+	return {
+		ownedCount,
+		totalSupplyCap,
+		remainingCount,
+		isLoading,
+		error: saleDetailsError,
+		saleDetails,
+	};
+}

package/src/react/hooks/useFloorOrder.tsx

@@ -20,9 +20,12 @@ export type UseFloorOrderArgs = z.infer<typeof UseFloorOrderSchema>;
 export type UseFloorOrderReturn = Awaited<ReturnType<typeof fetchFloorOrder>>;
 
 const fetchFloorOrder = async (args: UseFloorOrderArgs, config: SdkConfig) => {
-	const marketplaceClient = getMarketplaceClient(args.chainId, config);
+	const marketplaceClient = getMarketplaceClient(config);
 	return marketplaceClient
-		.getFloorOrder({ contractAddress: args.collectionAddress })
+		.getFloorOrder({
+			chainId: String(args.chainId),
+			contractAddress: args.collectionAddress,
+		})
 		.then((data) => data.collectible);
 };
 

package/src/react/hooks/useGenerateCancelTransaction.tsx

@@ -8,6 +8,14 @@ import {
 import { stepSchema } from '../_internal/api/zod-schema';
 import { useConfig } from './useConfig';
 
+// Create a type that uses number for chainId
+type GenerateCancelTransactionArgsWithNumberChainId = Omit<
+	GenerateCancelTransactionArgs,
+	'chainId'
+> & {
+	chainId: number;
+};
+
 const UserGenerateCancelTransactionArgsSchema = z.object({
 	chainId: z.number(),
 	onSuccess: z.function().args(stepSchema.array().optional()).optional(),
@@ -18,13 +26,12 @@ type UseGenerateCancelTransactionArgs = z.infer<
 >;
 
 export const generateCancelTransaction = async (
-	args: GenerateCancelTransactionArgs,
+	args: GenerateCancelTransactionArgsWithNumberChainId,
 	config: SdkConfig,
-	chainId: number,
 ) => {
-	const marketplaceClient = getMarketplaceClient(chainId, config);
+	const marketplaceClient = getMarketplaceClient(config);
 	return marketplaceClient
-		.generateCancelTransaction(args)
+		.generateCancelTransaction({ ...args, chainId: String(args.chainId) })
 		.then((data) => data.steps);
 };
 
@@ -35,8 +42,8 @@ export const useGenerateCancelTransaction = (
 
 	const { mutate, mutateAsync, ...result } = useMutation({
 		onSuccess: params.onSuccess,
-		mutationFn: (args: GenerateCancelTransactionArgs) =>
-			generateCancelTransaction(args, config, params.chainId),
+		mutationFn: (args: GenerateCancelTransactionArgsWithNumberChainId) =>
+			generateCancelTransaction(args, config),
 	});
 
 	return {

package/src/react/hooks/useGenerateListingTransaction.tsx

@@ -26,19 +26,27 @@ export type GenerateListingTransactionProps = Omit<
 	listing: CreateReqWithDateExpiry;
 };
 
+type GenerateListingTransactionArgsWithNumberChainId = Omit<
+	GenerateListingTransactionArgs,
+	'chainId' | 'listing'
+> & {
+	chainId: number;
+	listing: CreateReqWithDateExpiry;
+};
+
 export const generateListingTransaction = async (
-	params: GenerateListingTransactionProps,
+	params: GenerateListingTransactionArgsWithNumberChainId,
 	config: SdkConfig,
-	chainId: number,
 ) => {
 	const args = {
 		...params,
+		chainId: String(params.chainId),
 		listing: {
 			...params.listing,
 			expiry: dateToUnixTime(params.listing.expiry),
 		},
 	} satisfies GenerateListingTransactionArgs;
-	const marketplaceClient = getMarketplaceClient(chainId, config);
+	const marketplaceClient = getMarketplaceClient(config);
 	return (await marketplaceClient.generateListingTransaction(args)).steps;
 };
 
@@ -49,8 +57,10 @@ export const useGenerateListingTransaction = (
 
 	const { mutate, mutateAsync, ...result } = useMutation({
 		onSuccess: params.onSuccess,
-		mutationFn: (args: GenerateListingTransactionProps) =>
-			generateListingTransaction(args, config, params.chainId),
+		mutationFn: (
+			args: Omit<GenerateListingTransactionArgsWithNumberChainId, 'chainId'>,
+		) =>
+			generateListingTransaction({ ...args, chainId: params.chainId }, config),
 	});
 
 	return {

package/src/react/hooks/useGenerateOfferTransaction.tsx

@@ -27,18 +27,26 @@ export type GenerateOfferTransactionProps = Omit<
 	offer: CreateReqWithDateExpiry;
 };
 
+type GenerateOfferTransactionArgsWithNumberChainId = Omit<
+	GenerateOfferTransactionArgs,
+	'chainId' | 'offer'
+> & {
+	chainId: number;
+	offer: CreateReqWithDateExpiry;
+};
+
 export const generateOfferTransaction = async (
-	params: GenerateOfferTransactionProps,
+	params: GenerateOfferTransactionArgsWithNumberChainId,
 	config: SdkConfig,
-	chainId: number,
 	walletKind?: WalletKind,
 ) => {
 	const args = {
 		...params,
+		chainId: String(params.chainId),
 		offer: { ...params.offer, expiry: dateToUnixTime(params.offer.expiry) },
 		walletType: walletKind,
 	} satisfies GenerateOfferTransactionArgs;
-	const marketplaceClient = getMarketplaceClient(chainId, config);
+	const marketplaceClient = getMarketplaceClient(config);
 	return (await marketplaceClient.generateOfferTransaction(args)).steps;
 };
 
@@ -50,11 +58,12 @@ export const useGenerateOfferTransaction = (
 
 	const { mutate, mutateAsync, ...result } = useMutation({
 		onSuccess: params.onSuccess,
-		mutationFn: (args: GenerateOfferTransactionProps) =>
+		mutationFn: (
+			args: Omit<GenerateOfferTransactionArgsWithNumberChainId, 'chainId'>,
+		) =>
 			generateOfferTransaction(
-				args,
+				{ ...args, chainId: params.chainId },
 				config,
-				params.chainId,
 				wallet?.walletKind,
 			),
 	});

package/src/react/hooks/useGenerateSellTransaction.tsx

@@ -17,14 +17,22 @@ type UseGenerateSellTransactionArgs = z.infer<
 	typeof UserGeneratSellTransactionArgsSchema
 >;
 
+type GenerateSellTransactionArgsWithNumberChainId = Omit<
+	GenerateSellTransactionArgs,
+	'chainId'
+> & { chainId: number };
+
 export const generateSellTransaction = async (
-	args: GenerateSellTransactionArgs,
+	args: GenerateSellTransactionArgsWithNumberChainId,
 	config: SdkConfig,
-	chainId: number,
 ) => {
-	const marketplaceClient = getMarketplaceClient(chainId, config);
+	const marketplaceClient = getMarketplaceClient(config);
+	const argsWithStringChainId = {
+		...args,
+		chainId: String(args.chainId),
+	} satisfies GenerateSellTransactionArgs;
 	return marketplaceClient
-		.generateSellTransaction(args)
+		.generateSellTransaction(argsWithStringChainId)
 		.then((data) => data.steps);
 };
 
@@ -35,8 +43,9 @@ export const useGenerateSellTransaction = (
 
 	const { mutate, mutateAsync, ...result } = useMutation({
 		onSuccess: params.onSuccess,
-		mutationFn: (args: GenerateSellTransactionArgs) =>
-			generateSellTransaction(args, config, params.chainId),
+		mutationFn: (
+			args: Omit<GenerateSellTransactionArgsWithNumberChainId, 'chainId'>,
+		) => generateSellTransaction({ ...args, chainId: params.chainId }, config),
 	});
 
 	return {

package/src/react/hooks/useGetTokenSuppliesMap.ts

@@ -7,10 +7,14 @@ export const useGetTokenSuppliesMap = ({
 	chainId,
 	tokenIds,
 	collectionAddress,
+	query,
 }: {
 	chainId: number;
 	tokenIds: string[];
 	collectionAddress: string;
+	query?: {
+		enabled?: boolean;
+	};
 }) => {
 	const config = useConfig();
 	const indexerClient = getIndexerClient(chainId, config);
@@ -24,5 +28,6 @@ export const useGetTokenSuppliesMap = ({
 				includeMetadata: false,
 			});
 		},
+		enabled: query?.enabled,
 	});
 };

package/src/react/hooks/useInventory.tsx

@@ -1,16 +1,18 @@
 import { useInfiniteQuery } from '@tanstack/react-query';
-import { ContractType } from '../../types/api-types';
+import { ContractType } from '../_internal';
 import { type UseInventoryArgs, inventoryOptions } 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,130 @@
+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';
+
+interface UseList1155ShopCardDataProps {
+	tokenIds: string[];
+	chainId: number;
+	contractAddress: Address;
+	salesContractAddress: Address;
+	enabled?: boolean;
+}
+
+export function useList1155ShopCardData({
+	tokenIds,
+	chainId,
+	contractAddress,
+	salesContractAddress,
+	enabled = true,
+}: UseList1155ShopCardDataProps) {
+	const {
+		data: tokenMetadata,
+		isLoading: tokenMetadataLoading,
+		error: tokenMetadataError,
+	} = useListTokenMetadata({
+		chainId,
+		contractAddress,
+		tokenIds,
+		query: {
+			enabled,
+		},
+	});
+
+	const {
+		data: collectionDetails,
+		error: collectionDetailsError,
+		isLoading: collectionDetailsLoading,
+	} = useCollectionDetails({
+		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 isLoading =
+		tokenSaleDetailsLoading || tokenMetadataLoading || collectionDetailsLoading;
+
+	const collectibleCards = tokenIds.map((tokenId) => {
+		const token = tokenMetadata?.find((token) => token.tokenId === tokenId);
+
+		const saleData = extendedSupplyData?.find(
+			(data) => data.tokenId === 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;
+
+		return {
+			collectibleId: tokenId,
+			chainId,
+			collectionAddress: contractAddress as Address,
+			collectionType: ContractType.ERC1155,
+			tokenMetadata: token as 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,
+			marketplaceType: 'shop',
+		} satisfies ShopCollectibleCardProps;
+	});
+
+	return {
+		collectibleCards,
+		tokenMetadataError,
+		tokenSaleDetailsError,
+		collectionDetailsError,
+		isLoading,
+	};
+}

package/src/react/hooks/useList721ShopCardData.tsx

@@ -0,0 +1,130 @@
+import type { Address } from 'viem';
+import { useReadContract } from 'wagmi';
+import {
+	ContractType,
+	ERC721_SALE_ABI,
+	type TokenMetadata,
+} from '../../../../sdk/src';
+import type { ShopCollectibleCardProps } from '../ui/components/marketplace-collectible-card';
+import { useCollectionDetails } from './useCollectionDetails';
+import { useGetTokenSuppliesMap } from './useGetTokenSuppliesMap';
+import { useListTokenMetadata } from './useListTokenMetadata';
+
+interface UseList721ShopCardDataProps {
+	tokenIds: string[];
+	chainId: number;
+	contractAddress: Address;
+	salesContractAddress: Address;
+	enabled?: boolean;
+}
+
+export function useList721ShopCardData({
+	tokenIds,
+	chainId,
+	contractAddress,
+	salesContractAddress,
+	enabled = true,
+}: UseList721ShopCardDataProps) {
+	const {
+		data: tokenMetadata,
+		isLoading: tokenMetadataLoading,
+		error: tokenMetadataError,
+	} = useListTokenMetadata({
+		chainId,
+		contractAddress,
+		tokenIds,
+		query: {
+			enabled,
+		},
+	});
+
+	const {
+		data: collectionDetails,
+		error: collectionDetailsError,
+		isLoading: collectionDetailsLoading,
+	} = useCollectionDetails({
+		chainId,
+		collectionAddress: contractAddress,
+		query: {
+			enabled,
+		},
+	});
+
+	const { data: tokenSupplies, isLoading: tokenSuppliesLoading } =
+		useGetTokenSuppliesMap({
+			chainId,
+			tokenIds,
+			collectionAddress: contractAddress,
+			query: {
+				enabled,
+			},
+		});
+
+	// 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 ||
+		tokenMetadataLoading ||
+		collectionDetailsLoading ||
+		tokenSuppliesLoading;
+
+	const tokenSupplyMap = new Map(
+		tokenIds.map((tokenId) => {
+			const supplies = tokenSupplies?.supplies[contractAddress];
+			const supply = supplies?.find((s) => s.tokenID === tokenId);
+			// If supply exists and is greater than 0, token exists and is owned
+			return [tokenId, supply ? BigInt(supply.supply) > 0n : false];
+		}),
+	);
+
+	const collectibleCards = tokenIds.map((tokenId) => {
+		const token = tokenMetadata?.find((token) => token.tokenId === tokenId);
+		const hasOwner = tokenSupplyMap.get(tokenId) ?? false;
+
+		return {
+			collectibleId: tokenId,
+			chainId,
+			collectionAddress: contractAddress as Address,
+			collectionType: ContractType.ERC721,
+			tokenMetadata: token as TokenMetadata,
+			cardLoading: isLoading,
+			salesContractAddress: salesContractAddress as Address,
+			salePrice: {
+				amount: saleDetails?.cost?.toString() || '',
+				currencyAddress: saleDetails?.paymentToken ?? ('0x' as Address),
+			},
+			quantityInitial: saleDetails?.supplyCap
+				? saleDetails.supplyCap.toString()
+				: undefined,
+			quantityDecimals: collectionDetails?.tokenQuantityDecimals,
+			// Set quantityRemaining based on supply status
+			quantityRemaining: hasOwner ? undefined : '1',
+			saleStartsAt: saleDetails?.startTime?.toString(),
+			saleEndsAt: saleDetails?.endTime?.toString(),
+			marketplaceType: 'shop',
+		} satisfies ShopCollectibleCardProps;
+	});
+
+	return {
+		salePrice: collectibleCards[0]?.salePrice,
+		collectibleCards,
+		tokenMetadataError,
+		saleDetailsError,
+		collectionDetailsError,
+		saleDetails,
+		isLoading,
+	};
+}

package/src/react/hooks/useListBalances.tsx

@@ -1,5 +1,5 @@
 import { useInfiniteQuery } from '@tanstack/react-query';
-import { ContractType } from '../../types/api-types';
+import { ContractType } from '../_internal';
 import { listBalancesOptions } from '../queries/listBalances';
 import type { UseListBalancesArgs } from '../queries/listBalances';
 import { useConfig } from './useConfig';
@@ -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;
+		marketplaceConfig?.market?.collections?.find(
+			(c) =>
+				c.itemsAddress === args.contractAddress && c.chainId === args.chainId,
+		)?.contractType === ContractType.LAOS_ERC_721;
 
-	if (isLaos721) {
-		args.isLaos721 = true;
-	}
-
-	return useInfiniteQuery(listBalancesOptions(args, config));
+	return useInfiniteQuery(listBalancesOptions({ ...args, isLaos721 }, config));
 }

package/src/react/hooks/useListCollectibleActivities.tsx

@@ -20,9 +20,10 @@ const fetchCollectibleActivities = async (
 	args: UseListCollectibleActivitiesArgs,
 	config: SdkConfig,
 ) => {
-	const marketplaceClient = getMarketplaceClient(args.chainId, config);
+	const marketplaceClient = getMarketplaceClient(config);
 	return marketplaceClient
 		.listCollectibleActivities({
+			chainId: String(args.chainId),
 			contractAddress: args.collectionAddress,
 			tokenId: args.tokenId,
 			page: args.query?.enabled

package/src/react/hooks/useListCollectibles.tsx

@@ -1,9 +1,7 @@
 import { useInfiniteQuery } from '@tanstack/react-query';
-import { ContractType } from '../../types/api-types';
 import { listCollectiblesOptions } from '../queries/listCollectibles';
 import type { UseListCollectiblesArgs } from '../queries/listCollectibles';
 import { useConfig } from './useConfig';
-import { useMarketplaceConfig } from './useMarketplaceConfig';
 
 /**
  * Hook to fetch a list of collectibles with pagination support
@@ -26,16 +24,5 @@ import { useMarketplaceConfig } from './useMarketplaceConfig';
  */
 export function useListCollectibles(args: UseListCollectiblesArgs) {
 	const config = useConfig();
-	const { data: marketplaceConfig } = useMarketplaceConfig();
-
-	const isLaos721 =
-		marketplaceConfig?.market.collections.find(
-			(collection) => collection.itemsAddress === args.collectionAddress,
-		)?.contractType === ContractType.LAOSERC721;
-
-	if (isLaos721) {
-		args.isLaos721 = true;
-	}
-
-	return useInfiniteQuery(listCollectiblesOptions(args, config));
+	return useInfiniteQuery(listCollectiblesOptions({ ...args }, config));
 }

package/src/react/hooks/useListCollectiblesPaginated.tsx

@@ -45,11 +45,14 @@ const fetchCollectiblesPaginated = async (
 		pageSize: parsedArgs.query?.pageSize ?? 30,
 	};
 
-	const arg = {
-		...parsedArgs,
-		contractAddress: parsedArgs.collectionAddress,
+	const { chainId, collectionAddress, ...restArgs } = parsedArgs;
+	const arg: ListCollectiblesArgs = {
+		chainId: String(chainId),
+		contractAddress: collectionAddress,
 		page,
-	} as ListCollectiblesArgs;
+		side: restArgs.side,
+		filter: restArgs.filter,
+	};
 
 	return marketplaceClient.listCollectibles(arg);
 };
@@ -58,7 +61,7 @@ export const listCollectiblesPaginatedOptions = (
 	args: UseListCollectiblesPaginatedArgs,
 	config: SdkConfig,
 ) => {
-	const marketplaceClient = getMarketplaceClient(args.chainId, config);
+	const marketplaceClient = getMarketplaceClient(config);
 	return queryOptions({
 		queryKey: [...collectableKeys.lists, 'paginated', args],
 		queryFn: () => fetchCollectiblesPaginated(args, marketplaceClient),

package/src/react/hooks/useListCollectionActivities.tsx

@@ -21,9 +21,10 @@ const fetchListCollectionActivities = async (
 	args: UseListCollectionActivitiesArgs,
 	config: SdkConfig,
 ) => {
-	const marketplaceClient = getMarketplaceClient(args.chainId, config);
+	const marketplaceClient = getMarketplaceClient(config);
 	return marketplaceClient
 		.listCollectionActivities({
+			chainId: String(args.chainId),
 			contractAddress: args.collectionAddress,
 			page: args.query?.enabled
 				? {

package/src/react/hooks/useListCollections.tsx

@@ -1,5 +1,5 @@
 import { useQuery } from '@tanstack/react-query';
-import type { MarketplaceType } from '../../types/new-marketplace-types';
+import type { MarketplaceType } from '../../types/types';
 import { listCollectionsOptions } from '../queries/listCollections';
 import { useConfig } from './useConfig';
 import { useMarketplaceConfig } from './useMarketplaceConfig';