@0xsequence/marketplace-sdk 0.8.12 → 0.10.0

package/src/react/queries/countOffersForCollectible.ts

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

package/src/react/queries/currency.ts

@@ -0,0 +1,83 @@
+import { queryOptions, skipToken } from '@tanstack/react-query';
+import type { Address } from 'viem';
+import type { SdkConfig } from '../../types';
+import {
+	type Currency,
+	currencyKeys,
+	getMarketplaceClient,
+	getQueryClient,
+	type ValuesOptional,
+} from '../_internal';
+import type { StandardQueryOptions } from '../types/query';
+
+export interface FetchCurrencyParams {
+	chainId: number;
+	currencyAddress: Address;
+	config: SdkConfig;
+}
+
+/**
+ * Fetches currency details from the marketplace API
+ */
+export async function fetchCurrency(
+	params: FetchCurrencyParams,
+): Promise<Currency | undefined> {
+	const { chainId, currencyAddress, config } = params;
+	const queryClient = getQueryClient();
+
+	let currencies = queryClient.getQueryData([...currencyKeys.lists, chainId]) as
+		| Currency[]
+		| undefined;
+
+	if (!currencies) {
+		const marketplaceClient = getMarketplaceClient(config);
+		currencies = await marketplaceClient
+			.listCurrencies({ chainId: String(chainId) })
+			.then((resp) => resp.currencies);
+	}
+
+	if (!currencies?.length) {
+		throw new Error('No currencies returned');
+	}
+	const currency = currencies.find(
+		(currency) =>
+			currency.contractAddress.toLowerCase() === currencyAddress.toLowerCase(),
+	);
+
+	if (!currency) {
+		throw new Error('Currency not found');
+	}
+
+	return currency;
+}
+
+export type CurrencyQueryOptions = ValuesOptional<FetchCurrencyParams> & {
+	query?: StandardQueryOptions;
+};
+
+export function currencyQueryOptions(params: CurrencyQueryOptions) {
+	const enabled = Boolean(
+		params.chainId &&
+			params.currencyAddress &&
+			params.config &&
+			(params.query?.enabled ?? true),
+	);
+
+	return queryOptions({
+		queryKey: [...currencyKeys.details, params],
+		queryFn:
+			params.chainId && params.currencyAddress
+				? () =>
+						fetchCurrency({
+							// 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
+							currencyAddress: params.currencyAddress!,
+							// biome-ignore lint/style/noNonNullAssertion: The enabled check above ensures these are not undefined
+							config: params.config!,
+						})
+				: skipToken,
+		...params.query,
+		enabled,
+	});
+}

package/src/react/queries/filters.ts

@@ -0,0 +1,138 @@
+import type { PropertyFilter } from '@0xsequence/metadata';
+import { queryOptions } from '@tanstack/react-query';
+import { FilterCondition, type SdkConfig } from '../../types';
+import { compareAddress } from '../../utils';
+import {
+	getMetadataClient,
+	getQueryClient,
+	type ValuesOptional,
+} from '../_internal';
+import type { StandardQueryOptions } from '../types/query';
+import { marketplaceConfigOptions } from './marketplaceConfig';
+
+export interface FetchFiltersParams {
+	chainId: number;
+	collectionAddress: string;
+	showAllFilters?: boolean;
+	excludePropertyValues?: boolean;
+	config: SdkConfig;
+}
+
+/**
+ * Fetches collection filters from the Metadata API with optional marketplace filtering
+ */
+export async function fetchFilters(
+	params: FetchFiltersParams,
+): Promise<PropertyFilter[]> {
+	const {
+		chainId,
+		collectionAddress,
+		showAllFilters,
+		excludePropertyValues,
+		config,
+	} = params;
+
+	const metadataClient = getMetadataClient(config);
+
+	const filters = await metadataClient
+		.getTokenMetadataPropertyFilters({
+			chainID: chainId.toString(),
+			contractAddress: collectionAddress,
+			excludeProperties: [],
+			excludePropertyValues,
+		})
+		.then((resp) => resp.filters);
+
+	if (showAllFilters) return filters;
+
+	const queryClient = getQueryClient();
+	const marketplaceConfig = await queryClient.fetchQuery(
+		marketplaceConfigOptions(config),
+	);
+	const collectionFilters = marketplaceConfig.market.collections.find((c) =>
+		compareAddress(c.itemsAddress, collectionAddress),
+	)?.filterSettings;
+
+	if (
+		!collectionFilters?.exclusions ||
+		collectionFilters.exclusions.length === 0 ||
+		!collectionFilters.filterOrder ||
+		collectionFilters.filterOrder.length === 0
+	)
+		return filters;
+
+	const { filterOrder, exclusions } = collectionFilters;
+
+	const 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;
+	});
+
+	const filteredResults = 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 filteredResults;
+}
+
+export type FiltersQueryOptions = ValuesOptional<FetchFiltersParams> & {
+	query?: StandardQueryOptions;
+};
+
+export function filtersQueryOptions(params: FiltersQueryOptions) {
+	const enabled = Boolean(
+		params.chainId &&
+			params.collectionAddress &&
+			params.config &&
+			(params.query?.enabled ?? true),
+	);
+
+	return queryOptions({
+		queryKey: ['filters', params],
+		queryFn: () =>
+			fetchFilters({
+				// 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!,
+				showAllFilters: params.showAllFilters,
+				excludePropertyValues: params.excludePropertyValues,
+				// biome-ignore lint/style/noNonNullAssertion: The enabled check above ensures these are not undefined
+				config: params.config!,
+			}),
+		...params.query,
+		enabled,
+	});
+}

package/src/react/queries/floorOrder.ts

@@ -0,0 +1,63 @@
+import { queryOptions } from '@tanstack/react-query';
+import type { SdkConfig } from '../../types';
+import {
+	collectableKeys,
+	type GetFloorOrderArgs,
+	getMarketplaceClient,
+	type ValuesOptional,
+} from '../_internal';
+import type { StandardQueryOptions } from '../types/query';
+
+export interface FetchFloorOrderParams
+	extends Omit<GetFloorOrderArgs, 'contractAddress' | 'chainId'> {
+	collectionAddress: string;
+	chainId: number;
+	config: SdkConfig;
+}
+
+/**
+ * Fetches the floor order for a collection from the marketplace API
+ */
+export async function fetchFloorOrder(params: FetchFloorOrderParams) {
+	const { collectionAddress, chainId, config, ...additionalApiParams } = params;
+
+	const marketplaceClient = getMarketplaceClient(config);
+
+	const apiArgs: GetFloorOrderArgs = {
+		contractAddress: collectionAddress,
+		chainId: String(chainId),
+		...additionalApiParams,
+	};
+
+	const result = await marketplaceClient.getFloorOrder(apiArgs);
+	return result.collectible;
+}
+
+export type FloorOrderQueryOptions = ValuesOptional<FetchFloorOrderParams> & {
+	query?: StandardQueryOptions;
+};
+
+export function floorOrderQueryOptions(params: FloorOrderQueryOptions) {
+	const enabled = Boolean(
+		params.collectionAddress &&
+			params.chainId &&
+			params.config &&
+			(params.query?.enabled ?? true),
+	);
+
+	return queryOptions({
+		queryKey: [...collectableKeys.floorOrders, params],
+		queryFn: () =>
+			fetchFloorOrder({
+				// 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.filter && { filter: params.filter }) || {}),
+			}),
+		...params.query,
+		enabled,
+	});
+}

package/src/react/queries/getTokenRanges.ts

@@ -0,0 +1,62 @@
+import type { GetTokenIDRangesReturn } from '@0xsequence/indexer';
+import { queryOptions } from '@tanstack/react-query';
+import type { Address } from 'viem';
+import type { SdkConfig } from '../../types';
+import { getIndexerClient, type ValuesOptional } from '../_internal';
+import type { StandardQueryOptions } from '../types/query';
+
+export interface FetchGetTokenRangesParams {
+	chainId: number;
+	collectionAddress: Address;
+	config: SdkConfig;
+}
+
+/**
+ * Fetches token ID ranges for a collection from the Indexer API
+ */
+export async function fetchGetTokenRanges(
+	params: FetchGetTokenRangesParams,
+): Promise<GetTokenIDRangesReturn> {
+	const { chainId, collectionAddress, config } = params;
+
+	const indexerClient = getIndexerClient(chainId, config);
+
+	const response = await indexerClient.getTokenIDRanges({
+		contractAddress: collectionAddress,
+	});
+
+	if (!response) {
+		throw new Error('Failed to fetch token ranges');
+	}
+
+	return response;
+}
+
+export type GetTokenRangesQueryOptions =
+	ValuesOptional<FetchGetTokenRangesParams> & {
+		query?: StandardQueryOptions;
+	};
+
+export function getTokenRangesQueryOptions(params: GetTokenRangesQueryOptions) {
+	const enabled = Boolean(
+		params.chainId &&
+			params.collectionAddress &&
+			params.config &&
+			(params.query?.enabled ?? true),
+	);
+
+	return queryOptions({
+		queryKey: ['indexer', 'tokenRanges', params],
+		queryFn: () =>
+			fetchGetTokenRanges({
+				// 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/highestOffer.ts

@@ -1,60 +1,66 @@
 import { queryOptions } from '@tanstack/react-query';
-import type { Address } from 'viem';
 import type { SdkConfig } from '../../types';
 import {
-	type GetCollectibleHighestOfferArgs,
 	collectableKeys,
+	type GetCollectibleHighestOfferArgs,
 	getMarketplaceClient,
+	type ValuesOptional,
 } from '../_internal';
+import type { StandardQueryOptions } from '../types/query';
 
-export interface UseHighestOfferArgs
+export interface FetchHighestOfferParams
 	extends Omit<GetCollectibleHighestOfferArgs, 'contractAddress' | 'chainId'> {
-	collectionAddress: Address;
+	collectionAddress: string;
 	chainId: number;
-	query?: {
-		enabled?: boolean;
-	};
+	config: SdkConfig;
 }
 
-export async function fetchHighestOffer(
-	args: UseHighestOfferArgs,
-	config: SdkConfig,
-) {
+/**
+ * Fetches the highest offer for a collectible from the marketplace API
+ */
+export async function fetchHighestOffer(params: FetchHighestOfferParams) {
+	const { collectionAddress, chainId, config, ...additionalApiParams } = params;
+
 	const marketplaceClient = getMarketplaceClient(config);
 
-	const { chainId, collectionAddress, tokenId } = args;
-	const data = await marketplaceClient.getCollectibleHighestOffer({
-		chainId: String(chainId),
+	const apiArgs: GetCollectibleHighestOfferArgs = {
 		contractAddress: collectionAddress,
-		tokenId,
-	});
-
-	// let order: Order | undefined;
-	// if (data.order) {
-	// 	order = {
-	// 		...data.order,
-	// 		priceAmount: BigInt(data.order.priceAmount),
-	// 		priceAmountNet: BigInt(data.order.priceAmountNet),
-	// 	};
-	// }
+		chainId: String(chainId),
+		...additionalApiParams,
+	};
 
-	return data.order ?? null;
+	const result = await marketplaceClient.getCollectibleHighestOffer(apiArgs);
+	return result.order ?? null;
 }
 
-/**
- * Creates a tanstack query options object for the highest offer query
- *
- * @param args - The query arguments
- * @param config - SDK configuration
- * @returns Query options configuration
- */
-export function highestOfferOptions(
-	args: UseHighestOfferArgs,
-	config: SdkConfig,
-) {
+export type HighestOfferQueryOptions =
+	ValuesOptional<FetchHighestOfferParams> & {
+		query?: StandardQueryOptions;
+	};
+
+export function highestOfferQueryOptions(params: HighestOfferQueryOptions) {
+	const enabled = Boolean(
+		params.collectionAddress &&
+			params.chainId &&
+			params.tokenId &&
+			params.config &&
+			(params.query?.enabled ?? true),
+	);
+
 	return queryOptions({
-		enabled: args.query?.enabled ?? true,
-		queryKey: [...collectableKeys.highestOffers, args],
-		queryFn: () => fetchHighestOffer(args, config),
+		queryKey: [...collectableKeys.highestOffers, params],
+		queryFn: () =>
+			fetchHighestOffer({
+				// 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
+				tokenId: params.tokenId!,
+				// biome-ignore lint/style/noNonNullAssertion: The enabled check above ensures these are not undefined
+				config: params.config!,
+			}),
+		...params.query,
+		enabled,
 	});
 }

package/src/react/queries/index.ts

@@ -1,9 +1,15 @@
 export * from './balanceOfCollectible';
-export * from './getTokenSupplies';
-export * from './inventory';
-export * from './listCollectibles';
+export * from './collectible';
+export * from './collectionDetails';
+export * from './countOfPrimarySaleItems';
+export * from './currency';
+export * from './floorOrder';
 export * from './highestOffer';
+export * from './inventory';
 export * from './listBalances';
-export * from './lowestListing';
+export * from './listCollectibles';
+export * from './listCollections';
 export * from './listTokenMetadata';
+export * from './lowestListing';
 export * from './marketCurrencies';
+export * from './tokenSupplies';

package/src/react/queries/inventory.ts

@@ -9,10 +9,10 @@ import { OrderSide, type Page, type SdkConfig } from '../../types';
 import {
 	type CollectibleOrder,
 	type ContractType,
-	LaosAPI,
 	getIndexerClient,
+	LaosAPI,
 } from '../_internal';
-import { fetchCollectibles } from './listCollectibles';
+import { fetchListCollectibles } from './listCollectibles';
 import { fetchMarketplaceConfig } from './marketplaceConfig';
 
 export interface UseInventoryArgs {
@@ -38,6 +38,11 @@ interface InventoryState {
 // Store state per collection
 const stateByCollection = new Map<string, InventoryState>();
 
+// Test helper to clear state between tests
+export const clearInventoryState = () => {
+	stateByCollection.clear();
+};
+
 const getCollectionKey = (args: UseInventoryArgs) =>
 	`${args.chainId}-${args.collectionAddress}-${args.accountAddress}`;
 
@@ -105,6 +110,7 @@ async function fetchAllIndexerTokens(
 			chainId: chainId.toString(),
 			accountAddress,
 			includeMetadata: true,
+			contractAddress: collectionAddress,
 			page: {
 				sort: [
 					{
@@ -259,7 +265,7 @@ export async function fetchInventory(
 
 	// Fetch collectibles from marketplace API
 	const marketplaceConfig = await fetchMarketplaceConfig({ config });
-	const collectibles = await fetchCollectibles(
+	const collectibles = await fetchListCollectibles(
 		{
 			chainId,
 			collectionAddress,
@@ -268,8 +274,8 @@ export async function fetchInventory(
 				includeEmpty: true,
 			},
 			side: OrderSide.listing,
+			config,
 		},
-		config,
 		marketplaceConfig,
 		page,
 	);

package/src/react/queries/listBalances.ts

@@ -1,13 +1,13 @@
 import type { GetTokenBalancesReturn, Page } from '@0xsequence/indexer';
 import { infiniteQueryOptions } from '@tanstack/react-query';
-import type { Hex } from 'viem';
+import type { Address, Hex } from 'viem';
 import type { SdkConfig } from '../../types';
-import { LaosAPI, balanceQueries, getIndexerClient } from '../_internal';
+import { balanceQueries, getIndexerClient, LaosAPI } from '../_internal';
 
 export type UseListBalancesArgs = {
 	chainId: number;
-	accountAddress?: Hex;
-	contractAddress?: Hex;
+	accountAddress?: Address;
+	contractAddress?: Address;
 	tokenId?: string;
 	includeMetadata?: boolean;
 	metadataOptions?: {
@@ -34,6 +34,7 @@ export async function fetchBalances(
 		return laosClient.getTokenBalances({
 			chainId: args.chainId.toString(),
 			accountAddress: args.accountAddress,
+			contractAddress: args.contractAddress as Address,
 			includeMetadata: args.includeMetadata,
 			page: {
 				sort: [