@0xsequence/marketplace-sdk 1.2.1 → 2.0.1

package/src/react/queries/currency/list.ts

@@ -0,0 +1,103 @@
+import type {
+	Address,
+	Currency,
+	ListCurrenciesRequest,
+} from '@0xsequence/api-client';
+import { zeroAddress } from 'viem';
+import { compareAddress, findMarketCollection } from '../../../utils';
+import {
+	buildQueryOptions,
+	getMarketplaceClient,
+	getQueryClient,
+	type SdkQueryParams,
+	type WithOptionalParams,
+	type WithRequired,
+} from '../../_internal';
+import { marketplaceConfigOptions } from '../marketplace/config';
+
+export type FetchMarketCurrenciesParams = ListCurrenciesRequest & {
+	includeNativeCurrency?: boolean;
+	collectionAddress?: Address;
+};
+
+export type MarketCurrenciesQueryOptions =
+	SdkQueryParams<FetchMarketCurrenciesParams>;
+
+/**
+ * Fetches supported currencies for a marketplace
+ */
+export async function fetchMarketCurrencies(
+	params: WithRequired<MarketCurrenciesQueryOptions, 'chainId' | 'config'>,
+): Promise<Currency[]> {
+	const { chainId, includeNativeCurrency, collectionAddress, config } = params;
+	const includeNativeCurrencyOption = includeNativeCurrency ?? true;
+	const marketplaceClient = getMarketplaceClient(config);
+
+	let currencies = await marketplaceClient
+		.listCurrencies({
+			chainId,
+		})
+		.then((resp) =>
+			resp.currencies.map((currency) => ({
+				...currency,
+				contractAddress: currency.contractAddress || zeroAddress,
+			})),
+		);
+
+	if (collectionAddress) {
+		const queryClient = getQueryClient();
+		const marketplaceConfig = await queryClient.fetchQuery(
+			marketplaceConfigOptions(config),
+		);
+
+		const currenciesOptions = findMarketCollection(
+			marketplaceConfig.market.collections,
+			collectionAddress,
+			chainId,
+		)?.currencyOptions;
+
+		// Filter currencies based on collection currency options
+		if (currenciesOptions) {
+			currencies = currencies.filter((currency) =>
+				currenciesOptions.some((option) =>
+					compareAddress(option, currency.contractAddress),
+				),
+			);
+		}
+	}
+
+	if (!includeNativeCurrencyOption) {
+		currencies = currencies.filter((currency) => !currency.nativeCurrency);
+	}
+
+	return currencies;
+}
+
+export function getMarketCurrenciesQueryKey(
+	params: MarketCurrenciesQueryOptions,
+) {
+	return [
+		'currency',
+		'list',
+		{
+			chainId: params.chainId,
+			includeNativeCurrency: params.includeNativeCurrency,
+			collectionAddress: params.collectionAddress,
+		},
+	] as const;
+}
+
+export function marketCurrenciesQueryOptions(
+	params: WithOptionalParams<
+		WithRequired<MarketCurrenciesQueryOptions, 'chainId' | 'config'>
+	>,
+) {
+	return buildQueryOptions(
+		{
+			getQueryKey: getMarketCurrenciesQueryKey,
+			requiredParams: ['chainId', 'config'] as const,
+			fetcher: fetchMarketCurrencies,
+		},
+		params,
+	);
+}

package/src/react/queries/index.ts

@@ -1,8 +1,7 @@
-export * from './collectibles';
-export * from './collections';
+export * from './checkout';
+export * from './collectible';
+export * from './collection';
+export * from './currency';
 export * from './inventory';
-export * from './market';
-export * from './orders';
-export * from './primary-sales';
-export * from './tokens';
-export * from './utils';
+export * from './marketplace';
+export * from './token';

package/src/react/queries/inventory/inventory.ts

@@ -1,58 +1,78 @@
-import type { ContractInfo, TokenBalance } from '@0xsequence/indexer';
-import { queryOptions } from '@tanstack/react-query';
-import type { Address } from 'viem';
-import type { Page, SdkConfig } from '../../../types';
-import { compareAddress } from '../../../utils';
+import type {
+	ChainId,
+	GetUserCollectionBalancesRequest,
+	IndexerTokenMetadata,
+	IndexerTokenBalance as TokenBalance,
+} from '@0xsequence/api-client';
+import { ContractType, MetadataStatus } from '@0xsequence/api-client';
+import { isAddress } from 'viem';
+import type { Page } from '../../../types';
+import { findMarketCollection } from '../../../utils';
 import {
-	type ContractType,
+	buildQueryOptions,
 	getQueryClient,
-	MetadataStatus,
+	type SdkQueryParams,
+	type WithOptionalParams,
+	type WithRequired,
 } from '../../_internal';
-import { tokenBalancesOptions } from '../collectibles/tokenBalances';
-import { fetchMarketplaceConfig } from '../market/marketplaceConfig';
+import { tokenBalancesOptions } from '../collectible/token-balances';
+import { fetchMarketplaceConfig } from '../marketplace/config';
 
-export interface UseInventoryArgs {
-	accountAddress: Address;
-	collectionAddress: Address;
-	chainId: number;
+export type FetchInventoryParams = GetUserCollectionBalancesRequest & {
+	chainId: ChainId;
 	includeNonTradable?: boolean;
-	query?: {
-		enabled?: boolean;
-		page?: number;
-		pageSize?: number;
-	};
-}
-
-type GetInventoryArgs = Omit<UseInventoryArgs, 'query'>;
-
-interface CollectibleWithBalance {
-	metadata: {
-		tokenId: string;
-		attributes: Array<any>;
-		image?: string;
-		name: string;
-		description?: string;
-		video?: string;
-		audio?: string;
-		status: MetadataStatus;
-	};
+	page?: number;
+	pageSize?: number;
+};
+
+export type CollectibleMetadata = Pick<
+	IndexerTokenMetadata,
+	| 'tokenId'
+	| 'attributes'
+	| 'image'
+	| 'name'
+	| 'description'
+	| 'video'
+	| 'audio'
+> & {
+	status: MetadataStatus;
+};
+
+export type CollectibleWithBalance = Pick<TokenBalance, 'contractInfo'> & {
+	metadata: CollectibleMetadata;
 	balance: string;
-	contractInfo?: ContractInfo;
 	contractType: ContractType.ERC1155 | ContractType.ERC721;
-}
+};
 
-export interface CollectiblesResponse {
+export type CollectiblesResponse = {
 	collectibles: CollectibleWithBalance[];
 	page: Page;
 	isTradable: boolean;
+};
+
+/**
+ * Validates if a contract type is a valid collectible type (ERC721 or ERC1155)
+ */
+function isCollectibleContractType(
+	contractType: string,
+): contractType is ContractType.ERC721 | ContractType.ERC1155 {
+	// eslint-disable-next-line @typescript-eslint/no-unsafe-enum-comparison -- Intentional type guard comparing string with enum
+	return (
+		contractType === ContractType.ERC721 ||
+		contractType === ContractType.ERC1155
+	);
 }
 
+/**
+ * Transforms an Indexer token balance into a collectible with metadata
+ * @throws Error if token is not a valid collectible type (ERC721/ERC1155)
+ */
 function collectibleFromTokenBalance(
 	token: TokenBalance,
 ): CollectibleWithBalance {
 	return {
 		metadata: {
-			tokenId: token.tokenID ?? '',
+			tokenId: token.tokenId ?? 0n,
 			attributes: token.tokenMetadata?.attributes ?? [],
 			image: token.tokenMetadata?.image,
 			name: token.tokenMetadata?.name ?? '',
@@ -62,101 +82,131 @@ function collectibleFromTokenBalance(
 			status: MetadataStatus.AVAILABLE,
 		},
 		contractInfo: token.contractInfo,
-		contractType: token.contractType as unknown as
-			| ContractType.ERC1155
-			| ContractType.ERC721,
-		balance: token.balance,
+		contractType: token.contractType as
+			| ContractType.ERC721
+			| ContractType.ERC1155,
+		balance: token.balance.toString(),
 	};
 }
 
 async function fetchIndexerTokens(
-	chainId: number,
-	accountAddress: Address,
-	collectionAddress: Address,
-	config: SdkConfig,
+	params: WithRequired<
+		InventoryQueryOptions,
+		'chainId' | 'userAddress' | 'collectionAddress' | 'config'
+	>,
 ): Promise<{ collectibles: CollectibleWithBalance[] }> {
+	const { chainId, userAddress, collectionAddress, config } = params;
 	const queryClient = getQueryClient();
 	const balances = await queryClient.fetchQuery(
-		tokenBalancesOptions(
-			{
-				collectionAddress,
-				userAddress: accountAddress,
-				chainId,
-				includeMetadata: true,
-			},
+		tokenBalancesOptions({
+			collectionAddress,
+			userAddress,
+			chainId,
+			includeMetadata: true,
 			config,
-		),
+		}),
 	);
 
-	const collectibles = balances.map((balance) =>
-		collectibleFromTokenBalance(balance),
-	);
+	const collectibles = balances
+		.filter((balance) => isCollectibleContractType(balance.contractType))
+		.map((balance) => collectibleFromTokenBalance(balance));
 
 	return {
 		collectibles,
 	};
 }
 
+export type InventoryQueryOptions = SdkQueryParams<
+	FetchInventoryParams,
+	{
+		enabled?: boolean;
+	}
+>;
+
+/**
+ * @deprecated Use InventoryQueryOptions instead
+ */
+export type UseInventoryArgs = Omit<InventoryQueryOptions, 'config'> & {
+	config?: InventoryQueryOptions['config'];
+};
+
 export async function fetchInventory(
-	args: GetInventoryArgs,
-	config: SdkConfig,
-	page: Page,
+	params: WithRequired<
+		InventoryQueryOptions,
+		'userAddress' | 'collectionAddress' | 'chainId' | 'config'
+	>,
 ): Promise<CollectiblesResponse> {
-	const { accountAddress, collectionAddress, chainId } = args;
+	const {
+		userAddress,
+		collectionAddress,
+		chainId,
+		config,
+		page = 1,
+		pageSize = 30,
+	} = params;
 	const marketplaceConfig = await fetchMarketplaceConfig({ config });
 
 	const marketCollections = marketplaceConfig?.market.collections || [];
 
-	const isMarketCollection = marketCollections.some((collection) =>
-		compareAddress(collection.itemsAddress, collectionAddress),
+	const isMarketCollection = !!findMarketCollection(
+		marketCollections,
+		collectionAddress,
+		chainId,
 	);
 
 	// Determine if this collection is tradable (market collection vs shop collection)
 	const isTradable = isMarketCollection;
 
 	// Fetch collectibles from indexer
-	const { collectibles } = await fetchIndexerTokens(
+	const { collectibles } = await fetchIndexerTokens({
 		chainId,
-		accountAddress,
+		userAddress,
 		collectionAddress,
 		config,
-	);
+	});
 
 	return {
 		collectibles,
 		page: {
-			page: page.page,
-			pageSize: page.pageSize,
+			page,
+			pageSize,
 		},
 		isTradable,
 	};
 }
 
-export function inventoryOptions(args: UseInventoryArgs, config: SdkConfig) {
-	const enabledQuery = args.query?.enabled ?? true;
-	const enabled =
-		enabledQuery && !!args.accountAddress && !!args.collectionAddress;
-
-	return queryOptions({
-		queryKey: [
-			'inventory',
-			args.accountAddress,
-			args.collectionAddress,
-			args.chainId,
-			args.query?.page ?? 1,
-			args.query?.pageSize ?? 30,
-		],
-		queryFn: () =>
-			fetchInventory(
-				{
-					...args,
-				},
-				config,
-				{
-					page: args.query?.page ?? 1,
-					pageSize: args.query?.pageSize ?? 30,
-				},
-			),
-		enabled,
-	});
+export function getInventoryQueryKey(params: InventoryQueryOptions) {
+	return [
+		'inventory',
+		params.userAddress,
+		params.collectionAddress,
+		params.chainId,
+		params.page ?? 1,
+		params.pageSize ?? 30,
+	] as const;
+}
+
+export function inventoryOptions(
+	params: WithOptionalParams<
+		WithRequired<
+			InventoryQueryOptions,
+			'userAddress' | 'collectionAddress' | 'chainId' | 'config'
+		>
+	>,
+) {
+	return buildQueryOptions(
+		{
+			getQueryKey: getInventoryQueryKey,
+			requiredParams: [
+				'userAddress',
+				'collectionAddress',
+				'chainId',
+				'config',
+			] as const,
+			fetcher: fetchInventory,
+			customValidation: (p) =>
+				!!p.collectionAddress && isAddress(p.collectionAddress),
+		},
+		params,
+	);
 }

package/src/react/queries/marketplace/config.ts

@@ -0,0 +1,85 @@
+import type { Builder } from '@0xsequence/api-client';
+import { queryOptions } from '@tanstack/react-query';
+import type { MarketplaceConfig, SdkConfig } from '../../../types';
+import { getBuilderClient } from '../../_internal';
+import { persistentQueryMeta } from '../../_internal/query-meta';
+import { createMarketplaceQueryKey } from './queryKeys';
+
+export const fetchMarketplaceConfig = async ({
+	config,
+	prefetchedMarketplaceSettings,
+}: {
+	config: SdkConfig;
+	prefetchedMarketplaceSettings?: Builder.LookupMarketplaceReturn;
+}): Promise<MarketplaceConfig> => {
+	let builderMarketplaceConfig = prefetchedMarketplaceSettings;
+
+	if (!builderMarketplaceConfig) {
+		const builderApi = getBuilderClient(config);
+		const response = await builderApi.lookupMarketplace({
+			projectId: Number(config.projectId),
+		});
+
+		builderMarketplaceConfig = response;
+	}
+
+	if (!builderMarketplaceConfig) {
+		throw new Error('Failed to fetch marketplace config');
+	}
+
+	// The API wrapper's toLookupMarketplaceReturn transform already:
+	// 1. Nests collections within market.collections and shop.collections
+	// 2. Adds marketplaceCollectionType discriminator to each collection
+	// 3. Returns correctly typed MarketPage and ShopPage interfaces
+	// No transformation or type casting needed here!
+	const { market, shop, settings } = builderMarketplaceConfig.marketplace;
+
+	let marketplaceConfig: MarketplaceConfig = {
+		projectId: Number(config.projectId),
+		settings,
+		market,
+		shop,
+	};
+
+	if (config._internal?.overrides?.marketplaceConfig) {
+		const overrides = config._internal.overrides.marketplaceConfig;
+		marketplaceConfig = {
+			...marketplaceConfig,
+			...overrides,
+			market: {
+				...marketplaceConfig.market,
+				...overrides.market,
+				collections:
+					overrides.market?.collections ?? marketplaceConfig.market.collections,
+			},
+			shop: {
+				...marketplaceConfig.shop,
+				...overrides.shop,
+				collections:
+					overrides.shop?.collections ?? marketplaceConfig.shop.collections,
+			},
+		};
+	}
+
+	return marketplaceConfig;
+};
+
+export const marketplaceConfigOptions = (config: SdkConfig) => {
+	const prefetchedMarketplaceSettings =
+		config._internal?.prefetchedMarketplaceSettings;
+
+	return queryOptions({
+		queryKey: createMarketplaceQueryKey('config', {}),
+		queryFn: () =>
+			fetchMarketplaceConfig({
+				config,
+				prefetchedMarketplaceSettings,
+			}),
+		gcTime: Number.POSITIVE_INFINITY,
+		staleTime: Number.POSITIVE_INFINITY,
+		refetchOnMount: false,
+		refetchOnReconnect: false,
+		refetchOnWindowFocus: false,
+		meta: persistentQueryMeta,
+	});
+};

package/src/react/queries/marketplace/filters.ts

@@ -0,0 +1,141 @@
+import type { GetFiltersArgs, PropertyFilter } from '@0xsequence/api-client';
+import { isAddress } from 'viem';
+import { FilterCondition } from '../../../types';
+import { findMarketCollection } from '../../../utils';
+import {
+	buildQueryOptions,
+	getMetadataClient,
+	getQueryClient,
+	type SdkQueryParams,
+	type WithOptionalParams,
+	type WithRequired,
+} from '../../_internal';
+import { marketplaceConfigOptions } from './config';
+import { createMarketplaceQueryKey } from './queryKeys';
+
+export type FetchFiltersParams = GetFiltersArgs;
+
+/**
+ * Fetches collection filters from the Metadata API with optional marketplace filtering
+ */
+export async function fetchFilters(
+	params: WithRequired<
+		FiltersQueryOptions,
+		'chainId' | 'collectionAddress' | 'config'
+	>,
+): Promise<PropertyFilter[]> {
+	const {
+		chainId,
+		collectionAddress,
+		showAllFilters,
+		excludePropertyValues,
+		config,
+	} = params;
+
+	const metadataClient = getMetadataClient(config);
+
+	const result = await metadataClient.getTokenMetadataPropertyFilters({
+		chainId,
+		collectionAddress,
+		excludeProperties: [],
+		excludePropertyValues,
+	});
+
+	const filters = result.filters as PropertyFilter[];
+
+	if (showAllFilters) return filters;
+
+	const queryClient = getQueryClient();
+	const marketplaceConfig = await queryClient.fetchQuery(
+		marketplaceConfigOptions(config),
+	);
+	const collectionFilters = findMarketCollection(
+		marketplaceConfig.market.collections,
+		collectionAddress,
+		chainId,
+	)?.filterSettings;
+
+	const filterOrder = collectionFilters?.filterOrder;
+	const exclusions = collectionFilters?.exclusions;
+	let sortedFilters = filters;
+
+	if (filterOrder) {
+		sortedFilters = filters.toSorted((a, b) => {
+			const aIndex =
+				filterOrder.indexOf(a.name) > -1
+					? filterOrder.indexOf(a.name)
+					: filterOrder.length;
+			const bIndex =
+				filterOrder.indexOf(b.name) > -1
+					? filterOrder.indexOf(b.name)
+					: filterOrder.length;
+			return aIndex - bIndex;
+		});
+	}
+
+	if (exclusions) {
+		sortedFilters = sortedFilters.reduce<PropertyFilter[]>((acc, filter) => {
+			const exclusionRule = exclusions.find((rule) => rule.key === filter.name);
+
+			if (!exclusionRule) {
+				acc.push(filter);
+				return acc;
+			}
+
+			if (exclusionRule.condition === FilterCondition.ENTIRE_KEY) {
+				return acc;
+			}
+
+			if (
+				exclusionRule.condition === FilterCondition.SPECIFIC_VALUE &&
+				exclusionRule.value
+			) {
+				const filteredValues =
+					filter.values?.filter((value) => value !== exclusionRule.value) || [];
+				if (filteredValues.length > 0) {
+					acc.push({ ...filter, values: filteredValues });
+				}
+			}
+
+			return acc;
+		}, []);
+	}
+
+	return sortedFilters;
+}
+
+export type FiltersQueryOptions = SdkQueryParams<FetchFiltersParams>;
+
+export function getFiltersQueryKey(params: FiltersQueryOptions) {
+	const apiArgs = {
+		chainId: params.chainId,
+		collectionAddress: params.collectionAddress,
+		excludeProperties: undefined,
+		excludePropertyValues: params.excludePropertyValues,
+	};
+
+	return createMarketplaceQueryKey('filters', {
+		...apiArgs,
+		showAllFilters: params.showAllFilters,
+	});
+}
+
+export function filtersQueryOptions(
+	params: WithOptionalParams<
+		WithRequired<
+			FiltersQueryOptions,
+			'chainId' | 'collectionAddress' | 'config'
+		>
+	>,
+) {
+	return buildQueryOptions(
+		{
+			getQueryKey: getFiltersQueryKey,
+			requiredParams: ['chainId', 'collectionAddress', 'config'] as const,
+			fetcher: fetchFilters,
+			customValidation: (p) =>
+				!!p.collectionAddress && isAddress(p.collectionAddress),
+		},
+		params,
+	);
+}

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

@@ -0,0 +1,2 @@
+export * from './config';
+export * from './filters';

package/src/react/queries/marketplace/queryKeys.ts

@@ -0,0 +1,12 @@
+import { serializeBigInts } from '../../_internal/utils';
+
+/**
+ * Creates a type-safe query key for marketplace domain with automatic bigint serialization
+ *
+ * @param operation - The specific operation (e.g., 'config', 'filters')
+ * @param params - The query parameters (will be automatically serialized)
+ * @returns A serialized query key safe for React Query
+ */
+export function createMarketplaceQueryKey<T>(operation: string, params: T) {
+	return ['marketplace', operation, serializeBigInts(params)] as const;
+}