@0xsequence/marketplace-sdk 1.0.0 → 1.1.1

package/src/react/queries/collectibles/__tests__/tokenBalances.laos.test.ts

@@ -0,0 +1,123 @@
+import { server } from '@test';
+import { afterEach, describe, expect, it } from 'vitest';
+import {
+	laosHandlers,
+	mockTokenBalancesResponse,
+} from '../../../_internal/api/__mocks__/laos.msw';
+import { fetchTokenBalances } from '../tokenBalances';
+
+describe('fetchTokenBalances with LAOS', () => {
+	const mockConfig = {
+		projectAccessKey: 'test-key',
+		projectId: '1',
+		chainId: 11155111,
+		apiUrl: 'https://marketplace-api.sequence.app',
+		isDev: false,
+	};
+
+	afterEach(() => {
+		server.resetHandlers();
+	});
+
+	it('should use LAOS API when isLaos721=true', async () => {
+		server.use(...laosHandlers);
+
+		const result = await fetchTokenBalances(
+			{
+				collectionAddress: '0x1234567890123456789012345678901234567890',
+				userAddress: '0xuser1234567890123456789012345678901234567890',
+				chainId: 11155111,
+				isLaos721: true,
+			},
+			mockConfig,
+		);
+
+		// Should return array of balances from LAOS API response
+		expect(result).toEqual(mockTokenBalancesResponse.balances);
+		expect(result[0]?.balance).toBe('5');
+		expect(result[0]?.contractInfo?.type).toBe('LAOS-ERC-721');
+		expect(result[0]?.tokenMetadata?.name).toBe('Test Token 1');
+	});
+
+	it('should handle LAOS API errors', async () => {
+		server.use(...laosHandlers);
+
+		await expect(
+			fetchTokenBalances(
+				{
+					collectionAddress: '0x1234567890123456789012345678901234567890',
+					userAddress: '0x0000000000000000000000000000000000000001', // Special address for 500 error
+					chainId: 11155111,
+					isLaos721: true,
+				},
+				mockConfig,
+			),
+		).rejects.toThrow('Failed to get token balances: Internal Server Error');
+	});
+
+	it('should return empty array when LAOS API returns empty balances', async () => {
+		server.use(...laosHandlers);
+
+		const result = await fetchTokenBalances(
+			{
+				collectionAddress: '0x1234567890123456789012345678901234567890',
+				userAddress: '0x0000000000000000000000000000000000000003', // Special address for empty response
+				chainId: 11155111,
+				isLaos721: true,
+			},
+			mockConfig,
+		);
+
+		expect(result).toEqual([]);
+	});
+
+	it('should include metadata in LAOS response', async () => {
+		server.use(...laosHandlers);
+
+		const result = await fetchTokenBalances(
+			{
+				collectionAddress: '0x1234567890123456789012345678901234567890',
+				userAddress: '0xuser1234567890123456789012345678901234567890',
+				chainId: 11155111,
+				isLaos721: true,
+			},
+			mockConfig,
+		);
+
+		expect(result[0]?.tokenMetadata).toBeDefined();
+		expect(result[0]?.tokenMetadata?.name).toBe('Test Token 1');
+		expect(result[0]?.tokenMetadata?.description).toBe(
+			'A test token for LAOS testing',
+		);
+		expect(result[0]?.tokenMetadata?.image).toBe(
+			'https://example.com/token1.png',
+		);
+		expect(result[0]?.tokenMetadata?.attributes).toEqual([
+			{
+				trait_type: 'Rarity',
+				value: 'Common',
+			},
+		]);
+	});
+
+	it('should handle different pagination orders', async () => {
+		server.use(...laosHandlers);
+
+		const result = await fetchTokenBalances(
+			{
+				collectionAddress: '0x1234567890123456789012345678901234567890',
+				userAddress: '0xuser1234567890123456789012345678901234567890',
+				chainId: 11155111,
+				isLaos721: true,
+			},
+			mockConfig,
+		);
+
+		// Should return array of balances regardless of sort order
+		expect(result).toBeDefined();
+		expect(Array.isArray(result)).toBe(true);
+		expect(result.every((balance) => typeof balance.balance === 'string')).toBe(
+			true,
+		);
+	});
+});

package/src/react/queries/{balanceOfCollectible.ts → collectibles/balanceOfCollectible.ts}

@@ -1,8 +1,8 @@
 import { queryOptions, skipToken } from '@tanstack/react-query';
 import type { Address } from 'viem';
 import type { UseQueryParameters } from 'wagmi/query';
-import type { SdkConfig } from '../../types';
-import { collectableKeys, getIndexerClient, LaosAPI } from '../_internal';
+import type { SdkConfig } from '../../../types';
+import { collectableKeys, getIndexerClient, LaosAPI } from '../../_internal';
 
 export type UseBalanceOfCollectibleArgs = {
 	collectionAddress: Address;
@@ -10,6 +10,7 @@ export type UseBalanceOfCollectibleArgs = {
 	userAddress: Address | undefined;
 	chainId: number;
 	isLaos721?: boolean;
+	includeMetadata?: boolean;
 	query?: UseQueryParameters;
 };
 
@@ -44,7 +45,7 @@ export async function fetchBalanceOfCollectible(
 			accountAddress: args.userAddress,
 			contractAddress: args.collectionAddress,
 			tokenID: args.collectableId,
-			includeMetadata: false,
+			includeMetadata: args.includeMetadata ?? false,
 			metadataOptions: {
 				verifiedOnly: true,
 				includeContracts: [args.collectionAddress],
@@ -53,6 +54,27 @@ export async function fetchBalanceOfCollectible(
 		.then((res) => res.balances[0] || null);
 }
 
+export function getBalanceOfCollectibleQueryKey(
+	args: UseBalanceOfCollectibleArgs,
+) {
+	const apiArgs = {
+		chainId: args.chainId,
+		accountAddress: args.userAddress,
+		contractAddress: args.collectionAddress,
+		tokenID: args.collectableId,
+		includeMetadata: args.includeMetadata,
+		metadataOptions: args.userAddress
+			? {
+					verifiedOnly: true,
+					includeContracts: [args.collectionAddress],
+				}
+			: undefined,
+		isLaos721: args.isLaos721,
+	};
+
+	return [...collectableKeys.userBalances, apiArgs] as const;
+}
+
 /**
  * Creates a tanstack query options object for the balance query
  *
@@ -66,7 +88,7 @@ export function balanceOfCollectibleOptions(
 ) {
 	const enabled = !!args.userAddress && (args.query?.enabled ?? true);
 	return queryOptions({
-		queryKey: [...collectableKeys.userBalances, args],
+		queryKey: getBalanceOfCollectibleQueryKey(args),
 		queryFn: enabled
 			? () =>
 					fetchBalanceOfCollectible(

package/src/react/queries/{collectible.ts → collectibles/collectible.ts}

@@ -1,9 +1,13 @@
 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';
+import type { SdkConfig } from '../../../types';
+import {
+	getMetadataClient,
+	type QueryKeyArgs,
+	type ValuesOptional,
+} from '../../_internal';
+import { collectableKeys } from '../../_internal/api/query-keys';
+import type { StandardQueryOptions } from '../../types/query';
 
 export interface FetchCollectibleParams
 	extends Omit<
@@ -38,6 +42,17 @@ export type CollectibleQueryOptions = ValuesOptional<FetchCollectibleParams> & {
 	query?: StandardQueryOptions;
 };
 
+export function getCollectibleQueryKey(params: CollectibleQueryOptions) {
+	const apiArgs = {
+		chainID: String(params.chainId),
+		contractAddress: params.collectionAddress,
+		// biome-ignore lint/style/noNonNullAssertion: Dont need to validate here
+		tokenIDs: [params.collectibleId!],
+	} satisfies QueryKeyArgs<GetTokenMetadataArgs>;
+
+	return [...collectableKeys.details, apiArgs] as const;
+}
+
 export function collectibleQueryOptions(params: CollectibleQueryOptions) {
 	const enabled = Boolean(
 		params.collectionAddress &&
@@ -48,7 +63,7 @@ export function collectibleQueryOptions(params: CollectibleQueryOptions) {
 	);
 
 	return queryOptions({
-		queryKey: [...collectableKeys.details, params],
+		queryKey: getCollectibleQueryKey(params),
 		queryFn: () =>
 			fetchCollectible({
 				// biome-ignore lint/style/noNonNullAssertion: The enabled check above ensures these are not undefined

package/src/react/queries/{countOfCollectables.ts → collectibles/countOfCollectables.ts}

@@ -1,14 +1,18 @@
 import { queryOptions } from '@tanstack/react-query';
-import type { SdkConfig } from '../../types';
-import { getMarketplaceClient, type ValuesOptional } from '../_internal';
+import type { SdkConfig } from '../../../types';
+import {
+	getMarketplaceClient,
+	type QueryKeyArgs,
+	type ValuesOptional,
+} from '../../_internal';
 import type {
 	CollectiblesFilter,
 	GetCountOfAllCollectiblesArgs,
 	GetCountOfFilteredCollectiblesArgs,
 	OrderSide,
-} from '../_internal/api/marketplace.gen';
-import { collectableKeys } from '../_internal/api/query-keys';
-import type { StandardQueryOptions } from '../types/query';
+} from '../../_internal/api/marketplace.gen';
+import { collectableKeys } from '../../_internal/api/query-keys';
+import type { StandardQueryOptions } from '../../types/query';
 
 export interface FetchCountOfCollectablesParams {
 	chainId: number;
@@ -54,6 +58,28 @@ export type CountOfCollectablesQueryOptions =
 		query?: StandardQueryOptions;
 	};
 
+export function getCountOfCollectablesQueryKey(
+	params: CountOfCollectablesQueryOptions,
+) {
+	if (params.filter && params.side) {
+		const apiArgs = {
+			chainId: String(params.chainId),
+			contractAddress: params.collectionAddress,
+			filter: params.filter,
+			side: params.side,
+		} satisfies QueryKeyArgs<GetCountOfFilteredCollectiblesArgs>;
+
+		return [...collectableKeys.counts, apiArgs] as const;
+	}
+
+	const apiArgs = {
+		chainId: String(params.chainId),
+		contractAddress: params.collectionAddress,
+	} satisfies QueryKeyArgs<GetCountOfAllCollectiblesArgs>;
+
+	return [...collectableKeys.counts, apiArgs] as const;
+}
+
 export function countOfCollectablesQueryOptions(
 	params: CountOfCollectablesQueryOptions,
 ) {
@@ -65,7 +91,7 @@ export function countOfCollectablesQueryOptions(
 	);
 
 	return queryOptions({
-		queryKey: [...collectableKeys.counts, params],
+		queryKey: getCountOfCollectablesQueryKey(params),
 		queryFn: () =>
 			fetchCountOfCollectables({
 				// biome-ignore lint/style/noNonNullAssertion: The enabled check above ensures these are not undefined

package/src/react/queries/collectibles/index.ts

@@ -0,0 +1,7 @@
+export * from './balanceOfCollectible';
+export * from './collectible';
+export * from './countOfCollectables';
+export * from './listCollectibleActivities';
+export * from './listCollectibles';
+export * from './listCollectiblesPaginated';
+export * from './tokenBalances';

package/src/react/queries/{listCollectibleActivities.ts → collectibles/listCollectibleActivities.ts}

@@ -1,14 +1,15 @@
 import { queryOptions } from '@tanstack/react-query';
 import type { Address } from 'viem';
-import type { Page, SdkConfig } from '../../types';
+import type { Page, SdkConfig } from '../../../types';
 import type {
 	ListCollectibleActivitiesArgs,
 	ListCollectibleActivitiesReturn,
+	QueryKeyArgs,
 	SortBy,
 	ValuesOptional,
-} from '../_internal';
-import { collectableKeys, getMarketplaceClient } from '../_internal';
-import type { StandardQueryOptions } from '../types/query';
+} from '../../_internal';
+import { collectableKeys, getMarketplaceClient } from '../../_internal';
+import type { StandardQueryOptions } from '../../types/query';
 
 export interface FetchListCollectibleActivitiesParams
 	extends Omit<
@@ -64,6 +65,29 @@ export type ListCollectibleActivitiesQueryOptions =
 		query?: StandardQueryOptions;
 	};
 
+export function getListCollectibleActivitiesQueryKey(
+	params: ListCollectibleActivitiesQueryOptions,
+) {
+	// TODO: Do we actually want to do the page like this?
+	const page =
+		params.page || params.pageSize || params.sort
+			? {
+					page: params.page ?? 1,
+					pageSize: params.pageSize ?? 10,
+					sort: params.sort,
+				}
+			: undefined;
+
+	const apiArgs = {
+		chainId: String(params.chainId),
+		contractAddress: params.collectionAddress,
+		tokenId: params.tokenId,
+		page: page,
+	} satisfies QueryKeyArgs<ListCollectibleActivitiesArgs>;
+
+	return [...collectableKeys.collectibleActivities, apiArgs] as const;
+}
+
 export function listCollectibleActivitiesQueryOptions(
 	params: ListCollectibleActivitiesQueryOptions,
 ) {
@@ -76,7 +100,7 @@ export function listCollectibleActivitiesQueryOptions(
 	);
 
 	return queryOptions({
-		queryKey: [...collectableKeys.collectibleActivities, params],
+		queryKey: getListCollectibleActivitiesQueryKey(params),
 		queryFn: () =>
 			fetchListCollectibleActivities({
 				// biome-ignore lint/style/noNonNullAssertion: The enabled check above ensures these are not undefined

package/src/react/queries/{listCollectibles.ts → collectibles/listCollectibles.ts}

@@ -1,30 +1,36 @@
 import { infiniteQueryOptions } from '@tanstack/react-query';
 import type { Address } from 'viem';
-import type { MarketplaceConfig, Page, SdkConfig } from '../../types';
-import type { MarketplaceType } from '../../types/types';
-import { compareAddress } from '../../utils';
+import type { Page, SdkConfig } from '../../../types';
+import type { CardType } from '../../../types/types';
+import { compareAddress } from '../../../utils';
 import type {
 	ListCollectiblesArgs,
 	ListCollectiblesReturn,
+	QueryKeyArgs,
 	ValuesOptional,
-} from '../_internal';
+} from '../../_internal';
 import {
 	type CollectibleOrder,
 	collectableKeys,
 	getMarketplaceClient,
+	MetadataStatus,
 	OrderSide,
-} from '../_internal';
-import { fetchMarketplaceConfig } from '../queries/marketplaceConfig';
-import type { StandardInfiniteQueryOptions } from '../types/query';
-import { fetchBalances, type UseListBalancesArgs } from './listBalances';
+} from '../../_internal';
+import type { StandardInfiniteQueryOptions } from '../../types/query';
+import { fetchMarketplaceConfig } from '../market/marketplaceConfig';
+import {
+	fetchBalances,
+	type UseListBalancesArgs,
+} from '../tokens/listBalances';
 
 export interface FetchListCollectiblesParams
 	extends Omit<ListCollectiblesArgs, 'chainId' | 'contractAddress'> {
 	chainId: number;
 	collectionAddress: Address;
 	isLaos721?: boolean;
-	marketplaceType?: MarketplaceType;
+	cardType?: CardType;
 	config: SdkConfig;
+	enabled?: boolean;
 }
 
 /**
@@ -32,11 +38,26 @@ export interface FetchListCollectiblesParams
  */
 export async function fetchListCollectibles(
 	params: FetchListCollectiblesParams,
-	marketplaceConfig: MarketplaceConfig,
 	page: Page,
 ): Promise<ListCollectiblesReturn> {
 	const { collectionAddress, chainId, config, ...additionalApiParams } = params;
 	const marketplaceClient = getMarketplaceClient(config);
+	const marketplaceConfig = await fetchMarketplaceConfig({ config });
+	const isMarketCollection = marketplaceConfig?.market.collections.some(
+		(collection) => compareAddress(collection.itemsAddress, collectionAddress),
+	);
+
+	// If it's not a market collection, return an empty list. those collections are not compatible with the ListCollectibles endpoint.
+	if (params.enabled === false || !isMarketCollection) {
+		return {
+			collectibles: [],
+			page: {
+				page: 1,
+				pageSize: 30,
+				more: false,
+			},
+		};
+	}
 
 	const apiArgs: ListCollectiblesArgs = {
 		contractAddress: collectionAddress,
@@ -45,43 +66,6 @@ export async function fetchListCollectibles(
 		...additionalApiParams,
 	};
 
-	if (params.marketplaceType === 'shop') {
-		const shopCollection = marketplaceConfig.shop.collections.find(
-			(collection) =>
-				compareAddress(collection.itemsAddress, params.collectionAddress),
-		);
-
-		if (!shopCollection) {
-			return { collectibles: [] };
-		}
-
-		const primarySaleItemsList = await marketplaceClient.listPrimarySaleItems(
-			{
-				chainId: params.chainId.toString(),
-				primarySaleContractAddress: shopCollection.saleAddress as Address,
-			},
-			marketplaceConfig,
-		);
-
-		return {
-			collectibles: primarySaleItemsList.primarySaleItems.map((item) => ({
-				metadata: item.metadata,
-				primarySale: {
-					price: {
-						amount: item.primarySaleItem.priceAmount,
-						formatted: item.primarySaleItem.priceAmountFormatted,
-						decimals: item.primarySaleItem.priceDecimals,
-						currencyAddress: item.primarySaleItem.currencyAddress,
-					},
-					startDate: item.primarySaleItem.startDate,
-					endDate: item.primarySaleItem.endDate,
-					supplyCap: item.primarySaleItem.supply,
-					itemType: item.primarySaleItem.itemType,
-				},
-			})),
-		};
-	}
-
 	if (params.isLaos721 && params.side === OrderSide.listing) {
 		try {
 			const fetchBalancesArgs = {
@@ -107,6 +91,7 @@ export async function fetchListCollectibles(
 							description: balance.tokenMetadata.description,
 							video: balance.tokenMetadata.video,
 							audio: balance.tokenMetadata.audio,
+							status: MetadataStatus.AVAILABLE,
 						},
 					};
 				},
@@ -130,6 +115,19 @@ export type ListCollectiblesQueryOptions =
 		query?: StandardInfiniteQueryOptions;
 	};
 
+export function getListCollectiblesQueryKey(
+	params: ListCollectiblesQueryOptions,
+) {
+	const apiArgs = {
+		chainId: String(params.chainId),
+		contractAddress: params.collectionAddress,
+		side: params.side,
+		filter: params.filter,
+	} satisfies QueryKeyArgs<Omit<ListCollectiblesArgs, 'page'>>;
+
+	return [...collectableKeys.lists, apiArgs] as const;
+}
+
 export function listCollectiblesQueryOptions(
 	params: ListCollectiblesQueryOptions,
 ) {
@@ -142,12 +140,8 @@ export function listCollectiblesQueryOptions(
 	);
 
 	return infiniteQueryOptions({
-		queryKey: [...collectableKeys.lists, params],
+		queryKey: getListCollectiblesQueryKey(params),
 		queryFn: async ({ pageParam }) => {
-			const marketplaceConfig = await fetchMarketplaceConfig({
-				// biome-ignore lint/style/noNonNullAssertion: The enabled check above ensures these are not undefined
-				config: params.config!,
-			});
 			return fetchListCollectibles(
 				{
 					// biome-ignore lint/style/noNonNullAssertion: The enabled check above ensures these are not undefined
@@ -160,9 +154,8 @@ export function listCollectiblesQueryOptions(
 					side: params.side!,
 					filter: params.filter,
 					isLaos721: params.isLaos721,
-					marketplaceType: params.marketplaceType,
+					cardType: params.cardType,
 				},
-				marketplaceConfig,
 				pageParam,
 			);
 		},

package/src/react/queries/{listCollectiblesPaginated.ts → collectibles/listCollectiblesPaginated.ts}

@@ -1,13 +1,14 @@
 import { queryOptions } from '@tanstack/react-query';
 import type { Address } from 'viem';
-import type { Page, SdkConfig } from '../../types';
+import type { Page, SdkConfig } from '../../../types';
 import type {
 	ListCollectiblesArgs,
 	ListCollectiblesReturn,
+	QueryKeyArgs,
 	ValuesOptional,
-} from '../_internal';
-import { collectableKeys, getMarketplaceClient } from '../_internal';
-import type { StandardQueryOptions } from '../types/query';
+} from '../../_internal';
+import { collectableKeys, getMarketplaceClient } from '../../_internal';
+import type { StandardQueryOptions } from '../../types/query';
 
 export interface FetchListCollectiblesPaginatedParams
 	extends Omit<ListCollectiblesArgs, 'chainId' | 'contractAddress' | 'page'> {
@@ -54,6 +55,22 @@ export type ListCollectiblesPaginatedQueryOptions =
 		query?: StandardQueryOptions;
 	};
 
+export function getListCollectiblesPaginatedQueryKey(
+	params: ListCollectiblesPaginatedQueryOptions,
+) {
+	const apiArgs = {
+		chainId: String(params.chainId),
+		contractAddress: params.collectionAddress,
+		side: params.side,
+		filter: params.filter,
+		page: params.page
+			? { page: params.page, pageSize: params.pageSize ?? 30 }
+			: undefined,
+	} satisfies QueryKeyArgs<ListCollectiblesArgs>;
+
+	return [...collectableKeys.lists, 'paginated', apiArgs] as const;
+}
+
 export function listCollectiblesPaginatedQueryOptions(
 	params: ListCollectiblesPaginatedQueryOptions,
 ) {
@@ -66,7 +83,7 @@ export function listCollectiblesPaginatedQueryOptions(
 	);
 
 	return queryOptions({
-		queryKey: [...collectableKeys.lists, 'paginated', params],
+		queryKey: getListCollectiblesPaginatedQueryKey(params),
 		queryFn: () =>
 			fetchListCollectiblesPaginated({
 				// biome-ignore lint/style/noNonNullAssertion: The enabled check above ensures these are not undefined

package/src/react/queries/collectibles/tokenBalances.ts

@@ -0,0 +1,103 @@
+import { queryOptions, skipToken } from '@tanstack/react-query';
+import type { Address } from 'viem';
+import type { UseQueryParameters } from 'wagmi/query';
+import type { SdkConfig } from '../../../types';
+import { collectableKeys, getIndexerClient, LaosAPI } from '../../_internal';
+
+export type UseTokenBalancesArgs = {
+	collectionAddress: Address;
+	userAddress: Address | undefined;
+	chainId: number;
+	isLaos721?: boolean;
+	includeMetadata?: boolean;
+	query?: UseQueryParameters;
+};
+
+/**
+ * Fetches the token balances for a user
+ *
+ * @param args - Arguments for the API call
+ * @param config - SDK configuration
+ * @returns The balance data
+ */
+export async function fetchTokenBalances(
+	args: Omit<UseTokenBalancesArgs, 'userAddress'> & {
+		userAddress: Address;
+	},
+	config: SdkConfig,
+) {
+	if (args.isLaos721) {
+		const laosApi = new LaosAPI();
+		const response = await laosApi.getTokenBalances({
+			chainId: args.chainId.toString(),
+			contractAddress: args.collectionAddress,
+			accountAddress: args.userAddress,
+			includeMetadata: true,
+		});
+
+		return response.balances || [];
+	}
+
+	const indexerClient = getIndexerClient(args.chainId, config);
+	return indexerClient
+		.getTokenBalances({
+			accountAddress: args.userAddress,
+			contractAddress: args.collectionAddress,
+			includeMetadata: args.includeMetadata ?? false,
+			metadataOptions: {
+				verifiedOnly: true,
+				includeContracts: [args.collectionAddress],
+			},
+		})
+		.then((res) => res.balances || []);
+}
+
+export function getTokenBalancesQueryKey(args: UseTokenBalancesArgs) {
+	const apiArgs = {
+		chainId: args.chainId,
+		accountAddress: args.userAddress,
+		contractAddress: args.collectionAddress,
+		includeMetadata: args.includeMetadata,
+		metadataOptions: args.userAddress
+			? {
+					verifiedOnly: true,
+					includeContracts: [args.collectionAddress],
+				}
+			: undefined,
+		isLaos721: args.isLaos721,
+	};
+
+	return [...collectableKeys.userBalances, apiArgs] as const;
+}
+
+/**
+ * Creates a tanstack query options object for the token balances query
+ *
+ * @param args - The query arguments
+ * @param config - SDK configuration
+ * @returns Query options configuration
+ */
+export function tokenBalancesOptions(
+	args: UseTokenBalancesArgs,
+	config: SdkConfig,
+) {
+	const enabled =
+		!!args.userAddress &&
+		!!args.collectionAddress &&
+		(args.query?.enabled ?? true);
+
+	return queryOptions({
+		queryKey: getTokenBalancesQueryKey(args),
+		queryFn: enabled
+			? () =>
+					fetchTokenBalances(
+						{
+							...args,
+							// biome-ignore lint/style/noNonNullAssertion: this is guaranteed by the userAddress check above
+							userAddress: args.userAddress!,
+						},
+						config,
+					)
+			: skipToken,
+	});
+}