@0xsequence/marketplace-sdk 0.10.0 → 1.1.0

package/src/react/hooks/{useCountOfPrimarySaleItems.tsx → data/primary-sales/useCountOfPrimarySaleItems.tsx}

@@ -2,8 +2,8 @@ import { useQuery } from '@tanstack/react-query';
 import {
 	countOfPrimarySaleItemsOptions,
 	type UseCountOfPrimarySaleItemsArgs,
-} from '../queries';
-import { useConfig } from './useConfig';
+} from '../../../queries';
+import { useConfig } from '../../config/useConfig';
 
 export function useCountOfPrimarySaleItems(
 	args: UseCountOfPrimarySaleItemsArgs,

package/src/react/hooks/data/primary-sales/useErc721SalesData.tsx

@@ -0,0 +1,184 @@
+import type { Address } from 'viem';
+import { useReadContract } from 'wagmi';
+import {
+	ERC721_ABI,
+	ERC721_SALE_ABI_V0,
+	ERC721_SALE_ABI_V1,
+} from '../../../../utils';
+import { ContractType } from '../../../_internal';
+import {
+	SalesContractVersion,
+	useSalesContractABI,
+} from '../../contracts/useSalesContractABI';
+
+interface UseErc721CollectionDataProps {
+	chainId: number;
+	salesContractAddress: Address;
+	itemsContractAddress: Address;
+	enabled: boolean;
+}
+
+export function useErc721SaleDetails({
+	chainId,
+	salesContractAddress,
+	itemsContractAddress,
+	enabled,
+}: UseErc721CollectionDataProps) {
+	const {
+		version,
+		isLoading: versionLoading,
+		error: versionError,
+	} = useSalesContractABI({
+		contractAddress: salesContractAddress,
+		contractType: ContractType.ERC721,
+		chainId,
+		enabled,
+	});
+
+	const {
+		saleDetails: saleDetailsV0,
+		quantityMinted: quantityMintedV0,
+		quantityTotal: quantityTotalV0,
+		quantityRemaining: quantityRemainingV0,
+		isLoading: saleDetailsLoadingV0,
+		error: saleDetailsErrorV0,
+	} = useErc721SaleDetailsV0({
+		chainId,
+		salesContractAddress,
+		itemsContractAddress,
+		enabled: enabled && !versionLoading && version === SalesContractVersion.V0,
+	});
+
+	const {
+		saleDetails: saleDetailsV1,
+		quantityMinted: quantityMintedV1,
+		quantityTotal: quantityTotalV1,
+		quantityRemaining: quantityRemainingV1,
+		isLoading: saleDetailsLoadingV1,
+		error: saleDetailsErrorV1,
+	} = useErc721SaleDetailsV1({
+		chainId,
+		salesContractAddress,
+		itemsContractAddress,
+		enabled: enabled && !versionLoading && version === SalesContractVersion.V1,
+	});
+
+	const saleDetails = saleDetailsV0 || saleDetailsV1;
+	const quantityMinted = quantityMintedV0 || quantityMintedV1;
+	const quantityTotal = quantityTotalV0 || quantityTotalV1;
+	const quantityRemaining = quantityRemainingV0 || quantityRemainingV1;
+
+	return {
+		saleDetails,
+		quantityMinted,
+		quantityTotal,
+		quantityRemaining,
+		isLoading: versionLoading || saleDetailsLoadingV0 || saleDetailsLoadingV1,
+		error: versionError || saleDetailsErrorV0 || saleDetailsErrorV1,
+	};
+}
+
+const useErc721SaleDetailsV0 = ({
+	chainId,
+	salesContractAddress,
+	itemsContractAddress,
+	enabled,
+}: UseErc721CollectionDataProps) => {
+	const {
+		data: saleDetails,
+		isLoading: saleDetailsLoading,
+		error: saleDetailsError,
+	} = useReadContract({
+		chainId,
+		address: salesContractAddress,
+		abi: ERC721_SALE_ABI_V0,
+		functionName: 'saleDetails',
+		query: {
+			enabled,
+		},
+	});
+
+	const {
+		data: erc721TotalSupply,
+		isLoading: erc721SupplyLoading,
+		error: erc721SupplyError,
+	} = useReadContract({
+		chainId,
+		address: itemsContractAddress,
+		abi: ERC721_ABI,
+		functionName: 'totalSupply',
+		query: {
+			enabled,
+		},
+	});
+
+	const supplyCap = saleDetails?.supplyCap;
+	const totalMinted = erc721TotalSupply;
+
+	let quantityRemaining: bigint | undefined;
+	if (supplyCap !== undefined && totalMinted !== undefined) {
+		quantityRemaining = supplyCap - totalMinted;
+	}
+
+	return {
+		saleDetails,
+		quantityMinted: erc721TotalSupply,
+		quantityTotal: supplyCap,
+		quantityRemaining,
+		isLoading: saleDetailsLoading || erc721SupplyLoading,
+		error: saleDetailsError || erc721SupplyError,
+	};
+};
+
+const useErc721SaleDetailsV1 = ({
+	chainId,
+	salesContractAddress,
+	itemsContractAddress,
+	enabled,
+}: UseErc721CollectionDataProps) => {
+	const {
+		data: saleDetails,
+		isLoading: saleDetailsLoading,
+		error: saleDetailsError,
+	} = useReadContract({
+		chainId,
+		address: salesContractAddress,
+		abi: ERC721_SALE_ABI_V1,
+		functionName: 'saleDetails',
+		query: {
+			enabled,
+		},
+	});
+
+	const {
+		data: erc721TotalSupply,
+		isLoading: erc721SupplyLoading,
+		error: erc721SupplyError,
+	} = useReadContract({
+		chainId,
+		address: itemsContractAddress,
+		abi: ERC721_ABI,
+		functionName: 'totalSupply',
+		query: {
+			enabled,
+		},
+	});
+
+	let quantityTotal: bigint | undefined;
+
+	if (
+		saleDetails?.remainingSupply !== undefined &&
+		erc721TotalSupply !== undefined
+	) {
+		quantityTotal = erc721TotalSupply + saleDetails.remainingSupply;
+	}
+
+	return {
+		saleDetails,
+		quantityMinted: erc721TotalSupply,
+		quantityTotal,
+		quantityRemaining: saleDetails?.remainingSupply,
+		isLoading: saleDetailsLoading || erc721SupplyLoading,
+		error: saleDetailsError || erc721SupplyError,
+	};
+};

package/src/react/hooks/{useGetCountOfPrimarySaleItems.tsx → data/primary-sales/useGetCountOfPrimarySaleItems.tsx}

@@ -1,10 +1,10 @@
 'use client';
 
 import { useQuery } from '@tanstack/react-query';
-import type { Optional } from '../_internal';
-import type { ListPrimarySaleItemsQueryOptions } from '../queries/primarySaleItems';
-import { primarySaleItemsCountQueryOptions } from '../queries/primarySaleItemsCount';
-import { useConfig } from './useConfig';
+import type { Optional } from '../../../_internal';
+import type { ListPrimarySaleItemsQueryOptions } from '../../../queries/primarySaleItems';
+import { primarySaleItemsCountQueryOptions } from '../../../queries/primarySaleItemsCount';
+import { useConfig } from '../../config/useConfig';
 
 export type UseGetCountParams = Optional<
 	ListPrimarySaleItemsQueryOptions,

package/src/react/hooks/{useList1155ShopCardData.tsx → data/primary-sales/useList1155ShopCardData.tsx}

@@ -1,14 +1,19 @@
 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';
+import {
+	ContractType,
+	type PrimarySaleItem,
+	type TokenMetadata,
+} from '../../../_internal';
+import type { ShopCollectibleCardProps } from '../../../ui/components/marketplace-collectible-card/types';
+import { useSalesContractABI } from '../../contracts/useSalesContractABI';
+import { useCollection } from '../collections/useCollection';
 
 interface UseList1155ShopCardDataProps {
-	tokenIds: string[];
+	primarySaleItemsWithMetadata: Array<{
+		metadata: TokenMetadata;
+		primarySaleItem: PrimarySaleItem;
+	}>;
 	chainId: number;
 	contractAddress: Address;
 	salesContractAddress: Address;
@@ -16,56 +21,42 @@ interface UseList1155ShopCardDataProps {
 }
 
 export function useList1155ShopCardData({
-	tokenIds,
+	primarySaleItemsWithMetadata,
 	chainId,
 	contractAddress,
 	salesContractAddress,
 	enabled = true,
 }: UseList1155ShopCardDataProps) {
-	const { showListedOnly } = useFilterState();
-	const {
-		data: primarySaleItems,
-		isLoading: primarySaleItemsLoading,
-		error: primarySaleItemsError,
-	} = useListPrimarySaleItems({
+	const { abi, isLoading: versionLoading } = useSalesContractABI({
+		contractAddress: salesContractAddress,
+		contractType: ContractType.ERC1155,
 		chainId,
-		primarySaleContractAddress: salesContractAddress,
-		filter: {
-			includeEmpty: !showListedOnly,
-		},
+		enabled,
 	});
 
 	const { data: collection, isLoading: collectionLoading } = useCollection({
 		chainId,
 		collectionAddress: contractAddress,
+		query: {
+			enabled,
+		},
 	});
 
 	const { data: paymentToken, isLoading: paymentTokenLoading } =
 		useReadContract({
 			chainId,
 			address: salesContractAddress,
-			abi: ERC1155_SALES_CONTRACT_ABI,
+			abi: abi || [],
 			functionName: 'paymentToken',
 			query: {
-				enabled,
+				enabled: enabled && !versionLoading && !!abi,
 			},
 		});
 
-	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 isLoading = versionLoading || collectionLoading || paymentTokenLoading;
 
-		const saleData = matchingPrimarySaleItem?.primarySaleItem;
-		const tokenMetadata =
-			matchingPrimarySaleItem?.metadata || ({} as TokenMetadata);
+	const collectibleCards = primarySaleItemsWithMetadata.map((item) => {
+		const { metadata, primarySaleItem: saleData } = item;
 
 		const salePrice = {
 			amount: saleData?.priceAmount?.toString() || '',
@@ -78,11 +69,11 @@ export function useList1155ShopCardData({
 		const unlimitedSupply = saleData?.unlimitedSupply;
 
 		return {
-			collectibleId: tokenId,
+			collectibleId: metadata.tokenId,
 			chainId,
 			collectionAddress: contractAddress,
 			collectionType: ContractType.ERC1155,
-			tokenMetadata: tokenMetadata,
+			tokenMetadata: metadata,
 			cardLoading: isLoading,
 			salesContractAddress: salesContractAddress,
 			salePrice,
@@ -92,14 +83,14 @@ export function useList1155ShopCardData({
 			unlimitedSupply,
 			saleStartsAt: saleData?.startDate?.toString(),
 			saleEndsAt: saleData?.endDate?.toString(),
-			marketplaceType: 'shop',
+			cardType: 'shop',
 		} satisfies ShopCollectibleCardProps;
 	});
 
 	return {
 		collectibleCards,
-		tokenMetadataError: primarySaleItemsError,
+		tokenMetadataError: null,
 		tokenSaleDetailsError: null,
-		isLoading,
+		isLoading: enabled && isLoading,
 	};
 }

package/src/react/hooks/data/primary-sales/useList721ShopCardData.tsx

@@ -0,0 +1,194 @@
+import type { TokenMetadata } from '@0xsequence/metadata';
+import { useInfiniteQuery } from '@tanstack/react-query';
+import { useEffect, useState } from 'react';
+import type { Address } from 'viem';
+import { useReadContract } from 'wagmi';
+import { useFilterState } from '../../..';
+import { ContractType } from '../../../_internal';
+import type { CollectiblePrimarySaleItem } from '../../../_internal/api/marketplace.gen';
+import type { ShopCollectibleCardProps } from '../../../ui';
+import { useConfig } from '../../config';
+import { useSalesContractABI } from '../../contracts/useSalesContractABI';
+import { tokenSuppliesQueryOptions } from '../tokens';
+
+interface UseList721ShopCardDataProps {
+	primarySaleItemsWithMetadata: CollectiblePrimarySaleItem[];
+	chainId: number;
+	contractAddress: Address;
+	salesContractAddress: Address;
+	enabled?: boolean;
+}
+
+export function useList721ShopCardData({
+	primarySaleItemsWithMetadata,
+	chainId,
+	contractAddress,
+	salesContractAddress,
+	enabled = true,
+}: UseList721ShopCardDataProps) {
+	const [allTokenSuppliesFetched, setAllTokenSuppliesFetched] = useState(false);
+	const { showListedOnly: showAvailableSales } = useFilterState();
+
+	const { abi, isLoading: versionLoading } = useSalesContractABI({
+		contractAddress: salesContractAddress,
+		contractType: ContractType.ERC721,
+		chainId,
+		enabled,
+	});
+	const config = useConfig();
+
+	const tokenSuppliesEnabled = Boolean(
+		chainId && contractAddress && config && (enabled ?? true),
+	);
+	// TODO: Find a way to remove this and use enabled in tokenSuppliesQueryOptions
+	const tokenSuppliesQuery = useInfiniteQuery({
+		...tokenSuppliesQueryOptions({
+			chainId,
+			collectionAddress: contractAddress,
+			includeMetadata: true,
+			config,
+			query: {
+				enabled: tokenSuppliesEnabled,
+			},
+		}),
+	});
+
+	const {
+		data: tokenSuppliesData,
+		fetchNextPage: fetchNextTokenSuppliesPage,
+		hasNextPage: hasNextSuppliesPage,
+		isFetchingNextPage: isFetchingNextSuppliesPage,
+		isLoading: tokenSuppliesLoading,
+	} = tokenSuppliesQuery;
+
+	useEffect(() => {
+		async function fetchAllPages() {
+			if (!tokenSuppliesEnabled) return;
+
+			if (!hasNextSuppliesPage && tokenSuppliesData) {
+				setAllTokenSuppliesFetched(true);
+				return;
+			}
+
+			if (isFetchingNextSuppliesPage || tokenSuppliesLoading) return;
+
+			await fetchNextTokenSuppliesPage();
+		}
+
+		fetchAllPages();
+	}, [
+		hasNextSuppliesPage,
+		isFetchingNextSuppliesPage,
+		tokenSuppliesLoading,
+		fetchNextTokenSuppliesPage,
+		tokenSuppliesEnabled,
+	]);
+
+	const allTokenSupplies = tokenSuppliesData?.pages.flatMap(
+		(page) => page.tokenIDs,
+	);
+	const matchingTokenSupplies = allTokenSupplies?.filter((item) =>
+		primarySaleItemsWithMetadata.some(
+			(primarySaleItem) => primarySaleItem.metadata.tokenId === item.tokenID,
+		),
+	);
+
+	// For ERC721, we'll fetch the sale details directly from the contract
+	const {
+		data: saleDetails,
+		isLoading: saleDetailsLoading,
+		error: saleDetailsError,
+	} = useReadContract({
+		chainId,
+		address: salesContractAddress,
+		abi: abi || [],
+		functionName: 'saleDetails',
+		query: {
+			enabled: enabled && !versionLoading && !!abi,
+		},
+	});
+
+	// Filter out primary sale items that have already been minted
+	const unmintedPrimarySaleItems = primarySaleItemsWithMetadata.filter(
+		(item) =>
+			!matchingTokenSupplies?.some(
+				(supply) => supply.tokenID === item.metadata.tokenId,
+			),
+	);
+
+	const primarySaleItemsCollectibleCards = unmintedPrimarySaleItems.map(
+		(item) => {
+			const { metadata, primarySaleItem } = item;
+
+			const salePrice = {
+				amount: primarySaleItem.priceAmount?.toString(),
+				currencyAddress: primarySaleItem.currencyAddress as Address,
+			};
+
+			const quantityInitial = primarySaleItem.supply?.toString();
+
+			const quantityRemaining = '1';
+
+			const saleStartsAt = primarySaleItem.startDate.toString();
+
+			const saleEndsAt = primarySaleItem.endDate.toString();
+
+			return {
+				collectibleId: metadata.tokenId,
+				chainId,
+				collectionAddress: contractAddress,
+				collectionType: ContractType.ERC721,
+				tokenMetadata: metadata,
+				cardLoading: saleDetailsLoading,
+				salesContractAddress: salesContractAddress,
+				salePrice,
+				quantityInitial,
+				quantityRemaining,
+				quantityDecimals: 0,
+				saleStartsAt,
+				saleEndsAt,
+				cardType: 'shop',
+			} satisfies ShopCollectibleCardProps;
+		},
+	);
+
+	const mintedTokensCollectibleCards = allTokenSupplies?.map((item) => {
+		return {
+			collectibleId: item.tokenID,
+			chainId,
+			collectionAddress: contractAddress,
+			collectionType: ContractType.ERC721,
+			tokenMetadata: item.tokenMetadata as TokenMetadata,
+			cardLoading: saleDetailsLoading,
+			salesContractAddress: salesContractAddress,
+			salePrice: {
+				amount: '0',
+				currencyAddress: '0x0000000000000000000000000000000000000000',
+			},
+			quantityInitial: undefined,
+			quantityRemaining: undefined,
+			quantityDecimals: 0,
+			saleStartsAt: undefined,
+			saleEndsAt: undefined,
+			cardType: 'shop',
+		} satisfies ShopCollectibleCardProps;
+	});
+
+	const collectibleCards = showAvailableSales
+		? primarySaleItemsCollectibleCards
+		: [
+				...(mintedTokensCollectibleCards ?? []),
+				...primarySaleItemsCollectibleCards,
+			];
+
+	return {
+		salePrice: collectibleCards[0]?.salePrice,
+		collectibleCards,
+		saleDetailsError,
+		saleDetails,
+		isLoading:
+			enabled &&
+			(saleDetailsLoading || tokenSuppliesLoading || !allTokenSuppliesFetched),
+		tokenSuppliesData,
+	};
+}

package/src/react/hooks/{useListPrimarySaleItems.tsx → data/primary-sales/useListPrimarySaleItems.tsx}

@@ -1,12 +1,12 @@
 'use client';
 
 import { useInfiniteQuery } from '@tanstack/react-query';
-import type { Optional } from '../_internal';
+import type { Optional } from '../../../_internal';
 import {
 	type ListPrimarySaleItemsQueryOptions,
 	listPrimarySaleItemsQueryOptions,
-} from '../queries/primarySaleItems';
-import { useConfig } from './useConfig';
+} from '../../../queries/primarySaleItems';
+import { useConfig } from '../../config/useConfig';
 
 export type UseListPrimarySaleItemsParams = Optional<
 	ListPrimarySaleItemsQueryOptions,

package/src/react/hooks/data/tokens/index.ts

@@ -0,0 +1,5 @@
+export * from './useGetTokenRanges';
+export * from './useListBalances';
+export * from './useListTokenMetadata';
+export * from './useSearchTokenMetadata';
+export * from './useTokenSupplies';

package/src/react/hooks/{__tests__ → data/tokens}/useCurrencyBalance.test.tsx

@@ -1,8 +1,8 @@
 import { renderHook, waitFor } from '@test';
 import { zeroAddress } from 'viem';
 import { describe, expect, it } from 'vitest';
-import { USDC_ADDRESS, USDC_HOLDER } from '../../../../test/const';
-import { useCurrencyBalance } from '../useCurrencyBalance';
+import { USDC_ADDRESS, USDC_HOLDER } from '../../../../../test/const';
+import { useCurrencyBalance } from './useCurrencyBalance';
 
 describe('useCurrencyBalance', () => {
 	const defaultArgs = {

package/src/react/hooks/{__tests__ → data/tokens}/useGetTokenRanges.test.tsx

@@ -2,9 +2,9 @@ import { renderHook, server, waitFor } from '@test';
 import { HttpResponse, http } from 'msw';
 import { zeroAddress } from 'viem';
 import { describe, expect, it } from 'vitest';
-import { mockIndexerEndpoint } from '../../_internal/api/__mocks__/indexer.msw';
-import type { UseGetTokenRangesParams } from '../useGetTokenRanges';
-import { useGetTokenRanges } from '../useGetTokenRanges';
+import { mockIndexerEndpoint } from '../../../_internal/api/__mocks__/indexer.msw';
+import type { UseGetTokenRangesParams } from './useGetTokenRanges';
+import { useGetTokenRanges } from './useGetTokenRanges';
 
 describe('useGetTokenRanges', () => {
 	const defaultArgs: UseGetTokenRangesParams = {

package/src/react/hooks/{useGetTokenRanges.tsx → data/tokens/useGetTokenRanges.tsx}

@@ -2,13 +2,13 @@
 
 import { useQuery } from '@tanstack/react-query';
 import type { Address } from 'viem';
-import type { Optional } from '../_internal';
+import type { Optional } from '../../../_internal';
 import {
 	type FetchGetTokenRangesParams,
 	type GetTokenRangesQueryOptions,
 	getTokenRangesQueryOptions,
-} from '../queries/getTokenRanges';
-import { useConfig } from './useConfig';
+} from '../../../queries/getTokenRanges';
+import { useConfig } from '../../config/useConfig';
 
 export type UseGetTokenRangesParams = Optional<
 	GetTokenRangesQueryOptions,
@@ -88,5 +88,7 @@ export type UseGetTokenRangesProps = {
 };
 
 export type UseGetTokenRangesReturn = Awaited<
-	ReturnType<typeof import('../queries/getTokenRanges').fetchGetTokenRanges>
+	ReturnType<
+		typeof import('../../../queries/getTokenRanges').fetchGetTokenRanges
+	>
 >;

package/src/react/hooks/{__tests__ → data/tokens}/useListBalances.test.tsx

@@ -2,8 +2,8 @@ import { renderHook } from '@test';
 import { waitFor } from '@testing-library/react';
 import { zeroAddress } from 'viem';
 import { describe, expect, it } from 'vitest';
-import { mockTokenBalance } from '../../_internal/api/__mocks__/indexer.msw';
-import { useListBalances } from '../useListBalances';
+import { mockTokenBalance } from '../../../_internal/api/__mocks__/indexer.msw';
+import { useListBalances } from './useListBalances';
 
 describe('useListBalances', () => {
 	it('should fetch token balances successfully', async () => {

package/src/react/hooks/{useListBalances.tsx → data/tokens/useListBalances.tsx}

@@ -1,9 +1,9 @@
 import { useInfiniteQuery } from '@tanstack/react-query';
-import { ContractType } from '../_internal';
-import type { UseListBalancesArgs } from '../queries/listBalances';
-import { listBalancesOptions } from '../queries/listBalances';
-import { useConfig } from './useConfig';
-import { useMarketplaceConfig } from './useMarketplaceConfig';
+import { ContractType } from '../../../_internal';
+import type { UseListBalancesArgs } from '../../../queries/listBalances';
+import { listBalancesOptions } from '../../../queries/listBalances';
+import { useConfig } from '../../config/useConfig';
+import { useMarketplaceConfig } from '../../config/useMarketplaceConfig';
 
 /**
  * Hook to fetch a list of token balances with pagination support

package/src/react/hooks/{__tests__ → data/tokens}/useListTokenMetadata.test.tsx

@@ -5,9 +5,9 @@ import {
 	mockEthCollection,
 	mockMetadataEndpoint,
 	mockTokenMetadata,
-} from '../../_internal/api/__mocks__/metadata.msw';
-import type { UseListTokenMetadataParams } from '../useListTokenMetadata';
-import { useListTokenMetadata } from '../useListTokenMetadata';
+} from '../../../_internal/api/__mocks__/metadata.msw';
+import type { UseListTokenMetadataParams } from './useListTokenMetadata';
+import { useListTokenMetadata } from './useListTokenMetadata';
 
 describe('useListTokenMetadata', () => {
 	const defaultArgs: UseListTokenMetadataParams = {

package/src/react/hooks/{useListTokenMetadata.tsx → data/tokens/useListTokenMetadata.tsx}

@@ -1,13 +1,13 @@
 'use client';
 
 import { useQuery } from '@tanstack/react-query';
-import type { Optional } from '../_internal';
+import type { Optional } from '../../../_internal';
 import {
 	type FetchListTokenMetadataParams,
 	type ListTokenMetadataQueryOptions,
 	listTokenMetadataQueryOptions,
-} from '../queries/listTokenMetadata';
-import { useConfig } from './useConfig';
+} from '../../../queries/listTokenMetadata';
+import { useConfig } from '../../config/useConfig';
 
 export type UseListTokenMetadataParams = Optional<
 	ListTokenMetadataQueryOptions,