@0xsequence/marketplace-sdk 0.10.0 → 1.1.0

package/src/react/queries/inventory.ts

@@ -1,56 +1,39 @@
-import type {
-	ContractInfo,
-	Page as IndexerPage,
-	TokenBalance,
-} from '@0xsequence/indexer';
-import { infiniteQueryOptions } from '@tanstack/react-query';
+import type { ContractInfo, TokenBalance } from '@0xsequence/indexer';
+import { queryOptions } from '@tanstack/react-query';
 import type { Address } from 'viem';
-import { OrderSide, type Page, type SdkConfig } from '../../types';
-import {
-	type CollectibleOrder,
-	type ContractType,
-	getIndexerClient,
-	LaosAPI,
-} from '../_internal';
-import { fetchListCollectibles } from './listCollectibles';
+import type { Page, SdkConfig } from '../../types';
+import { compareAddress } from '../../utils';
+import { type ContractType, getQueryClient } from '../_internal';
 import { fetchMarketplaceConfig } from './marketplaceConfig';
+import { tokenBalancesOptions } from './tokenBalances';
 
 export interface UseInventoryArgs {
 	accountAddress: Address;
 	collectionAddress: Address;
 	chainId: number;
 	isLaos721?: boolean;
+	includeNonTradable?: boolean;
 	query?: {
 		enabled?: boolean;
+		page?: number;
+		pageSize?: number;
 	};
 }
 
-// Maintain collection state across calls
-interface InventoryState {
-	seenTokenIds: Set<string>;
-	marketplaceFinished: boolean;
-	// Track if we've already fetched all indexer tokens
-	indexerTokensFetched: boolean;
-	// Store the token balances from the indexer
-	indexerTokenBalances: Map<string, CollectibleWithBalance>;
-}
-
-// 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}`;
-
 interface GetInventoryArgs extends Omit<UseInventoryArgs, 'query'> {
 	isLaos721: boolean;
 }
 
-interface CollectibleWithBalance extends CollectibleOrder {
+interface CollectibleWithBalance {
+	metadata: {
+		tokenId: string;
+		attributes: Array<any>;
+		image?: string;
+		name: string;
+		description?: string;
+		video?: string;
+		audio?: string;
+	};
 	balance: string;
 	contractInfo?: ContractInfo;
 	contractType: ContractType.ERC1155 | ContractType.ERC721;
@@ -59,20 +42,7 @@ interface CollectibleWithBalance extends CollectibleOrder {
 export interface CollectiblesResponse {
 	collectibles: CollectibleWithBalance[];
 	page: Page;
-}
-
-function getOrInitState(collectionKey: string): InventoryState {
-	if (!stateByCollection.has(collectionKey)) {
-		stateByCollection.set(collectionKey, {
-			seenTokenIds: new Set<string>(),
-			marketplaceFinished: false,
-			indexerTokensFetched: false,
-			indexerTokenBalances: new Map(),
-		});
-	}
-
-	// biome-ignore lint/style/noNonNullAssertion: guaranteed to exist, by the above init
-	return stateByCollection.get(collectionKey)!;
+	isTradable: boolean;
 }
 
 function collectibleFromTokenBalance(
@@ -96,248 +66,98 @@ function collectibleFromTokenBalance(
 	};
 }
 
-async function fetchAllIndexerTokens(
+async function fetchIndexerTokens(
 	chainId: number,
 	accountAddress: Address,
 	collectionAddress: Address,
 	config: SdkConfig,
-	state: InventoryState,
 	isLaos721: boolean,
-): Promise<void> {
-	if (isLaos721) {
-		const laosClient = new LaosAPI();
-		const { balances } = await laosClient.getTokenBalances({
-			chainId: chainId.toString(),
-			accountAddress,
-			includeMetadata: true,
-			contractAddress: collectionAddress,
-			page: {
-				sort: [
-					{
-						column: 'CREATED_AT',
-						order: 'DESC',
-					},
-				],
+): Promise<{ collectibles: CollectibleWithBalance[] }> {
+	const queryClient = getQueryClient();
+	const balances = await queryClient.fetchQuery(
+		tokenBalancesOptions(
+			{
+				collectionAddress,
+				userAddress: accountAddress,
+				chainId,
+				isLaos721,
+				includeMetadata: true,
 			},
-		});
-
-		for (const balance of balances) {
-			if (balance.tokenID) {
-				state.indexerTokenBalances.set(
-					balance.tokenID,
-					collectibleFromTokenBalance(balance),
-				);
-			}
-		}
-
-		state.indexerTokensFetched = true;
-		return;
-	}
-
-	const indexerClient = getIndexerClient(chainId, config);
-
-	let page: IndexerPage = {
-		pageSize: 50,
-	};
-
-	while (true) {
-		const { balances, page: nextPage } = await indexerClient.getTokenBalances({
-			accountAddress,
-			contractAddress: collectionAddress,
-			includeMetadata: true,
-			page: page,
-		});
-
-		for (const balance of balances) {
-			if (balance.tokenID) {
-				state.indexerTokenBalances.set(
-					balance.tokenID,
-					collectibleFromTokenBalance(balance),
-				);
-			}
-		}
-
-		if (!nextPage.more) {
-			break;
-		}
-		page = nextPage;
-	}
-
-	state.indexerTokensFetched = true;
-}
-
-// Process indexer tokens that we haven't seen yet
-function processRemainingIndexerTokens(
-	state: InventoryState,
-	page: Page,
-): CollectiblesResponse {
-	const allTokens = Array.from(state.indexerTokenBalances.values());
-
-	// Filter out tokens that we've already seen
-	const newTokens = allTokens.filter(
-		(token) => !state.seenTokenIds.has(token.metadata.tokenId),
+			config,
+		),
 	);
 
-	// Calculate pagination
-	const startIndex = (page.page - 1) * page.pageSize;
-	const endIndex = startIndex + page.pageSize;
-	const paginatedTokens = newTokens.slice(startIndex, endIndex);
-
-	// Add new token IDs to the set
-	for (const token of paginatedTokens) {
-		state.seenTokenIds.add(token.metadata.tokenId);
-	}
+	const collectibles = balances.map((balance) =>
+		collectibleFromTokenBalance(balance),
+	);
 
 	return {
-		collectibles: paginatedTokens,
-		page: {
-			page: page.page,
-			pageSize: page.pageSize,
-			more: endIndex < newTokens.length,
-		},
+		collectibles,
 	};
 }
 
-function processMarketplaceCollectibles(
-	collectibles: CollectibleOrder[],
-	state: InventoryState,
-	page: Page,
-): {
-	enrichedCollectibles: CollectibleWithBalance[];
-	missingTokens: CollectibleWithBalance[];
-} {
-	// Add new token IDs to the set
-	for (const c of collectibles) {
-		state.seenTokenIds.add(c.metadata.tokenId);
-	}
-
-	// Enrich marketplace collectibles with balance data from indexer
-	const enrichedCollectibles = collectibles.map((c: CollectibleOrder) => {
-		const tokenId = c.metadata.tokenId;
-		const indexerData = state.indexerTokenBalances.get(tokenId);
-
-		return {
-			...c,
-			balance: indexerData?.balance,
-			contractInfo: indexerData?.contractInfo,
-			contractType: indexerData?.contractType,
-		} as CollectibleWithBalance;
-	});
-
-	// Check for missing tokens in the marketplace data
-	const marketplaceTokenIds = new Set(
-		enrichedCollectibles.map((c) => c.metadata.tokenId),
-	);
-
-	const missingTokens = Array.from(state.indexerTokenBalances.entries())
-		.filter(([tokenId]) => !marketplaceTokenIds.has(tokenId))
-		.map(([_, balance]) => balance)
-		.slice(0, page.pageSize);
-
-	return { enrichedCollectibles, missingTokens };
-}
-
 export async function fetchInventory(
 	args: GetInventoryArgs,
 	config: SdkConfig,
 	page: Page,
 ): Promise<CollectiblesResponse> {
 	const { accountAddress, collectionAddress, chainId, isLaos721 } = args;
-	const collectionKey = getCollectionKey(args);
-	const state = getOrInitState(collectionKey);
-
-	// On first run, fetch all pages from the indexer
-	if (!state.indexerTokensFetched) {
-		await fetchAllIndexerTokens(
-			chainId,
-			accountAddress,
-			collectionAddress,
-			config,
-			state,
-			isLaos721,
-		);
-	}
+	const marketplaceConfig = await fetchMarketplaceConfig({ config });
 
-	// If marketplace API has no more results, use the indexer data
-	if (state.marketplaceFinished) {
-		return processRemainingIndexerTokens(state, page);
-	}
+	const marketCollections = marketplaceConfig?.market.collections || [];
 
-	// Fetch collectibles from marketplace API
-	const marketplaceConfig = await fetchMarketplaceConfig({ config });
-	const collectibles = await fetchListCollectibles(
-		{
-			chainId,
-			collectionAddress,
-			filter: {
-				inAccounts: [accountAddress],
-				includeEmpty: true,
-			},
-			side: OrderSide.listing,
-			config,
-		},
-		marketplaceConfig,
-		page,
+	const isMarketCollection = marketCollections.some((collection) =>
+		compareAddress(collection.itemsAddress, collectionAddress),
 	);
 
-	// Process the collectibles and find missing tokens
-	const { enrichedCollectibles, missingTokens } =
-		processMarketplaceCollectibles(collectibles.collectibles, state, page);
+	// Determine if this collection is tradable (market collection vs shop collection)
+	const isTradable = isMarketCollection;
 
-	// If there are no more results from the marketplace API
-	if (!collectibles.page?.more) {
-		// Mark marketplace as finished and start using indexer data on next call
-		state.marketplaceFinished = true;
-		return {
-			collectibles: [...enrichedCollectibles, ...missingTokens],
-			page: {
-				page: collectibles.page?.page ?? page.page,
-				pageSize: collectibles.page?.pageSize ?? page.pageSize,
-				more: missingTokens.length > 0,
-			},
-		};
-	}
+	// Fetch collectibles from indexer
+	const { collectibles } = await fetchIndexerTokens(
+		chainId,
+		accountAddress,
+		collectionAddress,
+		config,
+		isLaos721,
+	);
 
 	return {
-		collectibles: enrichedCollectibles,
+		collectibles,
 		page: {
-			page: collectibles.page?.page ?? page.page,
-			pageSize: collectibles.page?.pageSize ?? page.pageSize,
-			more: Boolean(collectibles.page?.more),
+			page: page.page,
+			pageSize: page.pageSize,
 		},
+		isTradable,
 	};
 }
 
 export function inventoryOptions(args: UseInventoryArgs, config: SdkConfig) {
-	const collectionKey = getCollectionKey(args);
 	const enabledQuery = args.query?.enabled ?? true;
 	const enabled =
 		enabledQuery && !!args.accountAddress && !!args.collectionAddress;
 
-	return infiniteQueryOptions({
+	return queryOptions({
 		queryKey: [
 			'inventory',
 			args.accountAddress,
 			args.collectionAddress,
 			args.chainId,
+			args.query?.page ?? 1,
+			args.query?.pageSize ?? 30,
 		],
-		queryFn: ({ pageParam }) =>
+		queryFn: () =>
 			fetchInventory(
 				{
 					...args,
 					isLaos721: args.isLaos721 ?? false,
 				},
 				config,
-				pageParam,
+				{
+					page: args.query?.page ?? 1,
+					pageSize: args.query?.pageSize ?? 30,
+				},
 			),
-		initialPageParam: { page: 1, pageSize: 30 } as Page,
-		getNextPageParam: (lastPage) =>
-			lastPage.page?.more ? lastPage.page : undefined,
 		enabled,
-		meta: {
-			onInvalidate: () => {
-				stateByCollection.delete(collectionKey);
-			},
-		},
 	});
 }

package/src/react/queries/listCollectibles.ts

@@ -1,7 +1,7 @@
 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 type { Page, SdkConfig } from '../../types';
+import type { CardType } from '../../types/types';
 import { compareAddress } from '../../utils';
 import type {
 	ListCollectiblesArgs,
@@ -14,17 +14,18 @@ import {
 	getMarketplaceClient,
 	OrderSide,
 } from '../_internal';
-import { fetchMarketplaceConfig } from '../queries/marketplaceConfig';
 import type { StandardInfiniteQueryOptions } from '../types/query';
 import { fetchBalances, type UseListBalancesArgs } from './listBalances';
+import { fetchMarketplaceConfig } from './marketplaceConfig';
 
 export interface FetchListCollectiblesParams
 	extends Omit<ListCollectiblesArgs, 'chainId' | 'contractAddress'> {
 	chainId: number;
 	collectionAddress: Address;
 	isLaos721?: boolean;
-	marketplaceType?: MarketplaceType;
+	cardType?: CardType;
 	config: SdkConfig;
+	enabled?: boolean;
 }
 
 /**
@@ -32,11 +33,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 +61,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 = {
@@ -144,10 +123,6 @@ export function listCollectiblesQueryOptions(
 	return infiniteQueryOptions({
 		queryKey: [...collectableKeys.lists, 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 +135,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/listCollections.ts

@@ -1,6 +1,6 @@
 import type { ContractInfo } from '@0xsequence/metadata';
 import { queryOptions, skipToken } from '@tanstack/react-query';
-import type { MarketplaceType, SdkConfig } from '../../types';
+import type { CardType, SdkConfig } from '../../types';
 import type {
 	MarketCollection,
 	MarketplaceConfig,
@@ -22,7 +22,7 @@ const allCollections = (marketplaceConfig: MarketplaceConfig) => {
 };
 
 export interface FetchListCollectionsParams {
-	marketplaceType?: MarketplaceType;
+	cardType?: CardType;
 	marketplaceConfig: MarketplaceConfig;
 	config: SdkConfig;
 }
@@ -31,7 +31,7 @@ export interface FetchListCollectionsParams {
  * Fetches collections from the metadata API with marketplace config filtering
  */
 export async function fetchListCollections(params: FetchListCollectionsParams) {
-	const { marketplaceType, marketplaceConfig, config } = params;
+	const { cardType, marketplaceConfig, config } = params;
 	const metadataClient = getMetadataClient(config);
 
 	let collections = allCollections(marketplaceConfig);
@@ -40,9 +40,9 @@ export async function fetchListCollections(params: FetchListCollectionsParams) {
 		return [];
 	}
 
-	if (marketplaceType) {
+	if (cardType) {
 		collections = collections.filter(
-			(collection) => collection.marketplaceType === marketplaceType,
+			(collection) => collection.cardType === cardType,
 		);
 	}
 
@@ -131,7 +131,7 @@ export function listCollectionsQueryOptions(
 						marketplaceConfig: params.marketplaceConfig!,
 						// biome-ignore lint/style/noNonNullAssertion: The enabled check above ensures these are not undefined
 						config: params.config!,
-						marketplaceType: params.marketplaceType,
+						cardType: params.cardType,
 					})
 			: skipToken,
 		...params.query,
@@ -141,25 +141,22 @@ export function listCollectionsQueryOptions(
 
 // Keep old function for backward compatibility during migration
 export const listCollectionsOptions = ({
-	marketplaceType,
+	cardType,
 	marketplaceConfig,
 	config,
 }: {
-	marketplaceType?: MarketplaceType;
+	cardType?: CardType;
 	marketplaceConfig: MarketplaceConfig | undefined;
 	config: SdkConfig;
 }) => {
 	return queryOptions({
-		queryKey: [
-			...collectionKeys.list,
-			{ marketplaceType, marketplaceConfig, config },
-		],
+		queryKey: [...collectionKeys.list, { cardType, marketplaceConfig, config }],
 		queryFn: marketplaceConfig
 			? () =>
 					fetchListCollections({
 						marketplaceConfig,
 						config,
-						marketplaceType,
+						cardType,
 					})
 			: skipToken,
 		enabled: Boolean(marketplaceConfig),

package/src/react/queries/listOffersForCollectible.ts

@@ -0,0 +1,101 @@
+import { queryOptions } from '@tanstack/react-query';
+import type { Address } from 'viem';
+import type { SdkConfig } from '../../types';
+import type {
+	ListCollectibleOffersReturn,
+	ListOffersForCollectibleArgs,
+	Page,
+	SortBy,
+	ValuesOptional,
+} from '../_internal';
+import { collectableKeys, getMarketplaceClient } from '../_internal';
+import type { StandardQueryOptions } from '../types/query';
+
+export interface FetchListOffersForCollectibleParams
+	extends Omit<
+		ListOffersForCollectibleArgs,
+		'chainId' | 'contractAddress' | 'tokenId'
+	> {
+	chainId: number;
+	collectionAddress: Address;
+	collectibleId: string;
+	config: SdkConfig;
+	sort?: Array<SortBy>;
+}
+
+/**
+ * Fetches offers for a specific collectible from the Marketplace API
+ */
+export async function fetchListOffersForCollectible(
+	params: FetchListOffersForCollectibleParams,
+): Promise<ListCollectibleOffersReturn> {
+	const {
+		collectionAddress,
+		chainId,
+		collectibleId,
+		config,
+		sort,
+		page,
+		...additionalApiParams
+	} = params;
+	const marketplaceClient = getMarketplaceClient(config);
+
+	const finalSort = sort || (page && 'sort' in page ? page.sort : undefined);
+
+	let finalPage: Page | undefined;
+	if (page || finalSort) {
+		finalPage = {
+			page: page?.page ?? 1,
+			pageSize: page?.pageSize ?? 20,
+			...(page?.more && { more: page.more }),
+			...(finalSort && { sort: finalSort }),
+		} as Page;
+	}
+
+	const apiArgs: ListOffersForCollectibleArgs = {
+		contractAddress: collectionAddress,
+		chainId: String(chainId),
+		tokenId: collectibleId,
+		page: finalPage,
+		...additionalApiParams,
+	};
+
+	return await marketplaceClient.listCollectibleOffers(apiArgs);
+}
+
+export type ListOffersForCollectibleQueryOptions =
+	ValuesOptional<FetchListOffersForCollectibleParams> & {
+		query?: StandardQueryOptions;
+	};
+
+export function listOffersForCollectibleQueryOptions(
+	params: ListOffersForCollectibleQueryOptions,
+) {
+	const enabled = Boolean(
+		params.collectionAddress &&
+			params.chainId &&
+			params.collectibleId &&
+			params.config &&
+			(params.query?.enabled ?? true),
+	);
+
+	return queryOptions({
+		queryKey: [...collectableKeys.offers, params],
+		queryFn: () =>
+			fetchListOffersForCollectible({
+				// 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,
+				page: params.page,
+				sort: params.sort,
+			}),
+		...params.query,
+		enabled,
+	});
+}