@0xsequence/marketplace-sdk 0.8.12 → 0.9.0

package/src/react/queries/listCollectibles.ts

@@ -1,62 +1,54 @@
 import { infiniteQueryOptions } from '@tanstack/react-query';
-import type { Address, Hex } from 'viem';
+import type { Address } from 'viem';
 import type { MarketplaceConfig, Page, SdkConfig } from '../../types';
 import type { MarketplaceType } from '../../types/types';
 import { compareAddress } from '../../utils';
 import type {
-	CollectiblesFilter,
 	ListCollectiblesArgs,
 	ListCollectiblesReturn,
+	ValuesOptional,
 } from '../_internal';
 import {
 	type CollectibleOrder,
-	OrderSide,
 	collectableKeys,
 	getMarketplaceClient,
+	OrderSide,
 } from '../_internal';
 import { fetchMarketplaceConfig } from '../queries/marketplaceConfig';
-import { type UseListBalancesArgs, fetchBalances } from './listBalances';
+import type { StandardInfiniteQueryOptions } from '../types/query';
+import { fetchBalances, type UseListBalancesArgs } from './listBalances';
 
-export type UseListCollectiblesArgs = {
-	collectionAddress: Hex;
+export interface FetchListCollectiblesParams
+	extends Omit<ListCollectiblesArgs, 'chainId' | 'contractAddress'> {
 	chainId: number;
-	side: OrderSide;
-	filter?: CollectiblesFilter;
+	collectionAddress: Address;
 	isLaos721?: boolean;
 	marketplaceType?: MarketplaceType;
-	query?: {
-		enabled?: boolean;
-	};
-};
+	config: SdkConfig;
+}
 
 /**
- * Fetches a list of collectibles with pagination support
- *
- * @param args - Arguments for the API call
- * @param config - SDK configuration
- * @param page - Page parameters for pagination
- * @returns The collectibles data
+ * Fetches a list of collectibles with pagination support from the Marketplace API
  */
-export async function fetchCollectibles(
-	args: UseListCollectiblesArgs,
-	config: SdkConfig,
+export async function fetchListCollectibles(
+	params: FetchListCollectiblesParams,
 	marketplaceConfig: MarketplaceConfig,
 	page: Page,
 ): Promise<ListCollectiblesReturn> {
+	const { collectionAddress, chainId, config, ...additionalApiParams } = params;
 	const marketplaceClient = getMarketplaceClient(config);
-	const { chainId, collectionAddress, ...restArgs } = args;
-	const parsedArgs = {
-		...restArgs,
-		chainId: String(chainId),
+
+	const apiArgs: ListCollectiblesArgs = {
 		contractAddress: collectionAddress,
+		chainId: String(chainId),
 		page: page,
-		side: args.side,
-	} satisfies ListCollectiblesArgs;
+		...additionalApiParams,
+	};
 
-	if (args.marketplaceType === 'shop') {
+	if (params.marketplaceType === 'shop') {
 		const shopCollection = marketplaceConfig.shop.collections.find(
 			(collection) =>
-				compareAddress(collection.itemsAddress, args.collectionAddress),
+				compareAddress(collection.itemsAddress, params.collectionAddress),
 		);
 
 		if (!shopCollection) {
@@ -65,7 +57,7 @@ export async function fetchCollectibles(
 
 		const primarySaleItemsList = await marketplaceClient.listPrimarySaleItems(
 			{
-				chainId: args.chainId.toString(),
+				chainId: params.chainId.toString(),
 				primarySaleContractAddress: shopCollection.saleAddress as Address,
 			},
 			marketplaceConfig,
@@ -83,19 +75,19 @@ export async function fetchCollectibles(
 					},
 					startDate: item.primarySaleItem.startDate,
 					endDate: item.primarySaleItem.endDate,
-					supplyCap: item.primarySaleItem.supplyCap,
+					supplyCap: item.primarySaleItem.supply,
 					itemType: item.primarySaleItem.itemType,
 				},
 			})),
 		};
 	}
 
-	if (args.isLaos721 && args.side === OrderSide.listing) {
+	if (params.isLaos721 && params.side === OrderSide.listing) {
 		try {
 			const fetchBalancesArgs = {
-				chainId: args.chainId,
-				accountAddress: args.filter?.inAccounts?.[0] as Address,
-				contractAddress: args.collectionAddress,
+				chainId: params.chainId,
+				accountAddress: params.filter?.inAccounts?.[0] as Address,
+				contractAddress: params.collectionAddress,
 				page: page,
 				includeMetadata: true,
 				isLaos721: true,
@@ -130,29 +122,54 @@ export async function fetchCollectibles(
 		}
 	}
 
-	return await marketplaceClient.listCollectibles(parsedArgs);
+	return await marketplaceClient.listCollectibles(apiArgs);
 }
 
-/**
- * Creates a tanstack infinite query options object for the collectibles query
- *
- * @param args - The query arguments
- * @param config - SDK configuration
- * @returns Query options configuration
- */
-export function listCollectiblesOptions(
-	args: UseListCollectiblesArgs,
-	config: SdkConfig,
+export type ListCollectiblesQueryOptions =
+	ValuesOptional<FetchListCollectiblesParams> & {
+		query?: StandardInfiniteQueryOptions;
+	};
+
+export function listCollectiblesQueryOptions(
+	params: ListCollectiblesQueryOptions,
 ) {
+	const enabled = Boolean(
+		params.collectionAddress &&
+			params.chainId &&
+			params.side &&
+			params.config &&
+			(params.query?.enabled ?? true),
+	);
+
 	return infiniteQueryOptions({
-		...args.query,
-		queryKey: [...collectableKeys.lists, args, config],
+		queryKey: [...collectableKeys.lists, params],
 		queryFn: async ({ pageParam }) => {
-			const marketplaceConfig = await fetchMarketplaceConfig({ config });
-			return fetchCollectibles(args, config, marketplaceConfig, 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
+					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!,
+					// biome-ignore lint/style/noNonNullAssertion: The enabled check above ensures these are not undefined
+					side: params.side!,
+					filter: params.filter,
+					isLaos721: params.isLaos721,
+					marketplaceType: params.marketplaceType,
+				},
+				marketplaceConfig,
+				pageParam,
+			);
 		},
 		initialPageParam: { page: 1, pageSize: 30 } as Page,
 		getNextPageParam: (lastPage) =>
 			lastPage.page?.more ? lastPage.page : undefined,
+		...params.query,
+		enabled,
 	});
 }

package/src/react/queries/listCollectiblesPaginated.ts

@@ -0,0 +1,87 @@
+import { queryOptions } from '@tanstack/react-query';
+import type { Address } from 'viem';
+import type { Page, SdkConfig } from '../../types';
+import type {
+	ListCollectiblesArgs,
+	ListCollectiblesReturn,
+	ValuesOptional,
+} from '../_internal';
+import { collectableKeys, getMarketplaceClient } from '../_internal';
+import type { StandardQueryOptions } from '../types/query';
+
+export interface FetchListCollectiblesPaginatedParams
+	extends Omit<ListCollectiblesArgs, 'chainId' | 'contractAddress' | 'page'> {
+	chainId: number;
+	collectionAddress: Address;
+	page?: number;
+	pageSize?: number;
+	config: SdkConfig;
+}
+
+/**
+ * Fetches a list of collectibles with pagination support from the Marketplace API
+ */
+export async function fetchListCollectiblesPaginated(
+	params: FetchListCollectiblesPaginatedParams,
+): Promise<ListCollectiblesReturn> {
+	const {
+		collectionAddress,
+		chainId,
+		config,
+		page = 1,
+		pageSize = 30,
+		...additionalApiParams
+	} = params;
+	const marketplaceClient = getMarketplaceClient(config);
+
+	const pageParams: Page = {
+		page,
+		pageSize,
+	};
+
+	const apiArgs: ListCollectiblesArgs = {
+		contractAddress: collectionAddress,
+		chainId: String(chainId),
+		page: pageParams,
+		...additionalApiParams,
+	};
+
+	return await marketplaceClient.listCollectibles(apiArgs);
+}
+
+export type ListCollectiblesPaginatedQueryOptions =
+	ValuesOptional<FetchListCollectiblesPaginatedParams> & {
+		query?: StandardQueryOptions;
+	};
+
+export function listCollectiblesPaginatedQueryOptions(
+	params: ListCollectiblesPaginatedQueryOptions,
+) {
+	const enabled = Boolean(
+		params.collectionAddress &&
+			params.chainId &&
+			params.side &&
+			params.config &&
+			(params.query?.enabled ?? true),
+	);
+
+	return queryOptions({
+		queryKey: [...collectableKeys.lists, 'paginated', params],
+		queryFn: () =>
+			fetchListCollectiblesPaginated({
+				// 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!,
+				// biome-ignore lint/style/noNonNullAssertion: The enabled check above ensures these are not undefined
+				side: params.side!,
+				filter: params.filter,
+				page: params.page,
+				pageSize: params.pageSize,
+			}),
+		...params.query,
+		enabled,
+	});
+}

package/src/react/queries/listCollectionActivities.ts

@@ -0,0 +1,95 @@
+import { queryOptions } from '@tanstack/react-query';
+import type { Address } from 'viem';
+import type { Page, SdkConfig } from '../../types';
+import type {
+	ListCollectionActivitiesArgs,
+	ListCollectionActivitiesReturn,
+	SortBy,
+	ValuesOptional,
+} from '../_internal';
+import { getMarketplaceClient } from '../_internal';
+import { collectionKeys } from '../_internal/api';
+import type { StandardQueryOptions } from '../types/query';
+
+export interface FetchListCollectionActivitiesParams
+	extends Omit<
+		ListCollectionActivitiesArgs,
+		'chainId' | 'contractAddress' | 'page'
+	> {
+	chainId: number;
+	collectionAddress: Address;
+	page?: number;
+	pageSize?: number;
+	sort?: SortBy[];
+	config: SdkConfig;
+}
+
+/**
+ * Fetches collection activities from the Marketplace API
+ */
+export async function fetchListCollectionActivities(
+	params: FetchListCollectionActivitiesParams,
+): Promise<ListCollectionActivitiesReturn> {
+	const {
+		collectionAddress,
+		chainId,
+		config,
+		page,
+		pageSize,
+		sort,
+		...additionalApiParams
+	} = params;
+	const marketplaceClient = getMarketplaceClient(config);
+
+	const pageParams: Page | undefined =
+		page || pageSize || sort
+			? {
+					page: page ?? 1,
+					pageSize: pageSize ?? 10,
+					sort,
+				}
+			: undefined;
+
+	const apiArgs: ListCollectionActivitiesArgs = {
+		contractAddress: collectionAddress,
+		chainId: String(chainId),
+		page: pageParams,
+		...additionalApiParams,
+	};
+
+	return await marketplaceClient.listCollectionActivities(apiArgs);
+}
+
+export type ListCollectionActivitiesQueryOptions =
+	ValuesOptional<FetchListCollectionActivitiesParams> & {
+		query?: StandardQueryOptions;
+	};
+
+export function listCollectionActivitiesQueryOptions(
+	params: ListCollectionActivitiesQueryOptions,
+) {
+	const enabled = Boolean(
+		params.collectionAddress &&
+			params.chainId &&
+			params.config &&
+			(params.query?.enabled ?? true),
+	);
+
+	return queryOptions({
+		queryKey: [...collectionKeys.collectionActivities, params],
+		queryFn: () =>
+			fetchListCollectionActivities({
+				// 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!,
+				page: params.page,
+				pageSize: params.pageSize,
+				sort: params.sort,
+			}),
+		...params.query,
+		enabled,
+	});
+}

package/src/react/queries/listCollections.ts

@@ -7,7 +7,12 @@ import type {
 	ShopCollection,
 } from '../../types/new-marketplace-types';
 import { compareAddress } from '../../utils';
-import { collectionKeys, getMetadataClient } from '../_internal';
+import {
+	collectionKeys,
+	getMetadataClient,
+	type ValuesOptional,
+} from '../_internal';
+import type { StandardQueryOptions } from '../types/query';
 
 const allCollections = (marketplaceConfig: MarketplaceConfig) => {
 	return [
@@ -16,15 +21,17 @@ const allCollections = (marketplaceConfig: MarketplaceConfig) => {
 	];
 };
 
-const fetchListCollections = async ({
-	marketplaceType,
-	marketplaceConfig,
-	config,
-}: {
+export interface FetchListCollectionsParams {
 	marketplaceType?: MarketplaceType;
 	marketplaceConfig: MarketplaceConfig;
 	config: SdkConfig;
-}) => {
+}
+
+/**
+ * Fetches list of collections from the metadata API with marketplace filtering
+ */
+export async function fetchListCollections(params: FetchListCollectionsParams) {
+	const { marketplaceType, marketplaceConfig, config } = params;
 	const metadataClient = getMetadataClient(config);
 
 	let collections = allCollections(marketplaceConfig);
@@ -99,8 +106,40 @@ const fetchListCollections = async ({
 		}));
 
 	return collectionsWithMetadata;
-};
+}
+
+export type ListCollectionsQueryOptions =
+	ValuesOptional<FetchListCollectionsParams> & {
+		query?: StandardQueryOptions;
+	};
+
+export function listCollectionsQueryOptions(
+	params: ListCollectionsQueryOptions,
+) {
+	const enabled = Boolean(
+		params.marketplaceConfig &&
+			params.config &&
+			(params.query?.enabled ?? true),
+	);
+
+	return queryOptions({
+		queryKey: [...collectionKeys.list, params],
+		queryFn: enabled
+			? () =>
+					fetchListCollections({
+						// biome-ignore lint/style/noNonNullAssertion: The enabled check above ensures these are not undefined
+						marketplaceConfig: params.marketplaceConfig!,
+						// biome-ignore lint/style/noNonNullAssertion: The enabled check above ensures these are not undefined
+						config: params.config!,
+						marketplaceType: params.marketplaceType,
+					})
+			: skipToken,
+		...params.query,
+		enabled,
+	});
+}
 
+// Keep old function for backward compatibility during migration
 export const listCollectionsOptions = ({
 	marketplaceType,
 	marketplaceConfig,

package/src/react/queries/listListingsForCollectible.ts

@@ -0,0 +1,82 @@
+import { queryOptions } from '@tanstack/react-query';
+import type { Address } from 'viem';
+import type { SdkConfig } from '../../types';
+import type {
+	ListCollectibleListingsArgs,
+	ListCollectibleListingsReturn,
+	ValuesOptional,
+} from '../_internal';
+import { collectableKeys, getMarketplaceClient } from '../_internal';
+import type { StandardQueryOptions } from '../types/query';
+
+export interface FetchListListingsForCollectibleParams
+	extends Omit<
+		ListCollectibleListingsArgs,
+		'chainId' | 'contractAddress' | 'tokenId'
+	> {
+	chainId: number;
+	collectionAddress: Address;
+	collectibleId: string;
+	config: SdkConfig;
+}
+
+/**
+ * Fetches listings for a specific collectible from the Marketplace API
+ */
+export async function fetchListListingsForCollectible(
+	params: FetchListListingsForCollectibleParams,
+): Promise<ListCollectibleListingsReturn> {
+	const {
+		collectionAddress,
+		chainId,
+		collectibleId,
+		config,
+		...additionalApiParams
+	} = params;
+	const marketplaceClient = getMarketplaceClient(config);
+
+	const apiArgs: ListCollectibleListingsArgs = {
+		contractAddress: collectionAddress,
+		chainId: String(chainId),
+		tokenId: collectibleId,
+		...additionalApiParams,
+	};
+
+	return await marketplaceClient.listCollectibleListings(apiArgs);
+}
+
+export type ListListingsForCollectibleQueryOptions =
+	ValuesOptional<FetchListListingsForCollectibleParams> & {
+		query?: StandardQueryOptions;
+	};
+
+export function listListingsForCollectibleQueryOptions(
+	params: ListListingsForCollectibleQueryOptions,
+) {
+	const enabled = Boolean(
+		params.collectionAddress &&
+			params.chainId &&
+			params.collectibleId &&
+			params.config &&
+			(params.query?.enabled ?? true),
+	);
+
+	return queryOptions({
+		queryKey: [...collectableKeys.listings, params],
+		queryFn: () =>
+			fetchListListingsForCollectible({
+				// 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,
+			}),
+		...params.query,
+		enabled,
+	});
+}

package/src/react/queries/listTokenMetadata.ts

@@ -1,20 +1,26 @@
 import { queryOptions } from '@tanstack/react-query';
 import type { SdkConfig } from '../../types';
-import { getMetadataClient } from '../_internal';
+import {
+	getMetadataClient,
+	metadataKeys,
+	type ValuesOptional,
+} from '../_internal';
+import type { StandardQueryOptions } from '../types/query';
 
-export interface FetchTokenMetadataArgs {
+export interface FetchListTokenMetadataParams {
 	chainId: number;
 	contractAddress: string;
 	tokenIds: string[];
-	query?: {
-		enabled?: boolean;
-	};
+	config: SdkConfig;
 }
 
-const fetchTokenMetadata = async (
-	{ chainId, contractAddress, tokenIds }: FetchTokenMetadataArgs,
-	config: SdkConfig,
-) => {
+/**
+ * Fetches token metadata from the metadata API
+ */
+export async function fetchListTokenMetadata(
+	params: FetchListTokenMetadataParams,
+) {
+	const { chainId, contractAddress, tokenIds, config } = params;
 	const metadataClient = getMetadataClient(config);
 
 	const response = await metadataClient.getTokenMetadata({
@@ -24,20 +30,38 @@ const fetchTokenMetadata = async (
 	});
 
 	return response.tokenMetadata;
-};
+}
+
+export type ListTokenMetadataQueryOptions =
+	ValuesOptional<FetchListTokenMetadataParams> & {
+		query?: StandardQueryOptions;
+	};
+
+export function listTokenMetadataQueryOptions(
+	params: ListTokenMetadataQueryOptions,
+) {
+	const enabled = Boolean(
+		params.chainId &&
+			params.contractAddress &&
+			params.tokenIds?.length &&
+			params.config &&
+			(params.query?.enabled ?? true),
+	);
 
-export const tokenMetadataOptions = (
-	args: FetchTokenMetadataArgs,
-	config: SdkConfig,
-) => {
 	return queryOptions({
-		...args.query,
-		queryKey: [
-			'listTokenMetadata',
-			args.chainId,
-			args.contractAddress,
-			args.tokenIds,
-		],
-		queryFn: () => fetchTokenMetadata(args, config),
+		queryKey: [...metadataKeys.tokenMetadata, params],
+		queryFn: () =>
+			fetchListTokenMetadata({
+				// 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
+				contractAddress: params.contractAddress!,
+				// biome-ignore lint/style/noNonNullAssertion: The enabled check above ensures these are not undefined
+				tokenIds: params.tokenIds!,
+				// biome-ignore lint/style/noNonNullAssertion: The enabled check above ensures these are not undefined
+				config: params.config!,
+			}),
+		...params.query,
+		enabled,
 	});
-};
+}