@0xsequence/marketplace-sdk 0.8.12 → 0.9.0

package/src/react/queries/countOfCollectables.ts

@@ -0,0 +1,83 @@
+import { queryOptions } from '@tanstack/react-query';
+import type { SdkConfig } from '../../types';
+import { getMarketplaceClient, 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';
+
+export interface FetchCountOfCollectablesParams {
+	chainId: number;
+	collectionAddress: string;
+	config: SdkConfig;
+	filter?: CollectiblesFilter;
+	side?: OrderSide;
+}
+
+/**
+ * Fetches count of collectibles from the marketplace API
+ */
+export async function fetchCountOfCollectables(
+	params: FetchCountOfCollectablesParams,
+) {
+	const { collectionAddress, chainId, config, filter, side } = params;
+
+	const client = getMarketplaceClient(config);
+
+	if (filter && side) {
+		const apiArgs: GetCountOfFilteredCollectiblesArgs = {
+			contractAddress: collectionAddress,
+			chainId: String(chainId),
+			filter,
+			side,
+		};
+
+		const result = await client.getCountOfFilteredCollectibles(apiArgs);
+		return result.count;
+	}
+
+	const apiArgs: GetCountOfAllCollectiblesArgs = {
+		contractAddress: collectionAddress,
+		chainId: String(chainId),
+	};
+
+	const result = await client.getCountOfAllCollectibles(apiArgs);
+	return result.count;
+}
+
+export type CountOfCollectablesQueryOptions =
+	ValuesOptional<FetchCountOfCollectablesParams> & {
+		query?: StandardQueryOptions;
+	};
+
+export function countOfCollectablesQueryOptions(
+	params: CountOfCollectablesQueryOptions,
+) {
+	const enabled = Boolean(
+		params.collectionAddress &&
+			params.chainId &&
+			params.config &&
+			(params.query?.enabled ?? true),
+	);
+
+	return queryOptions({
+		queryKey: [...collectableKeys.counts, params],
+		queryFn: () =>
+			fetchCountOfCollectables({
+				// 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!,
+				filter: params.filter,
+				side: params.side,
+			}),
+		...params.query,
+		enabled,
+	});
+}

package/src/react/queries/countOfPrimarySaleItems.ts

@@ -0,0 +1,48 @@
+import { queryOptions } from '@tanstack/react-query';
+import type { Address } from 'viem';
+import type { SdkConfig } from '../../types';
+import {
+	type GetCountOfPrimarySaleItemsArgs,
+	getMarketplaceClient,
+	type PrimarySaleItemsFilter,
+} from '../_internal';
+
+export interface UseCountOfPrimarySaleItemsArgs
+	extends Omit<
+		GetCountOfPrimarySaleItemsArgs,
+		'chainId' | 'primarySaleContractAddress'
+	> {
+	chainId: number;
+	primarySaleContractAddress: Address;
+	filter?: PrimarySaleItemsFilter;
+	query?: {
+		enabled?: boolean;
+	};
+}
+
+export async function fetchCountOfPrimarySaleItems(
+	args: UseCountOfPrimarySaleItemsArgs,
+	config: SdkConfig,
+) {
+	const marketplaceClient = getMarketplaceClient(config);
+
+	const { chainId, primarySaleContractAddress, filter } = args;
+	const data = await marketplaceClient.getCountOfPrimarySaleItems({
+		chainId: String(chainId),
+		primarySaleContractAddress,
+		filter,
+	});
+
+	return data.count;
+}
+
+export function countOfPrimarySaleItemsOptions(
+	args: UseCountOfPrimarySaleItemsArgs,
+	config: SdkConfig,
+) {
+	return queryOptions({
+		enabled: args.query?.enabled ?? true,
+		queryKey: ['countOfPrimarySaleItems', args],
+		queryFn: () => fetchCountOfPrimarySaleItems(args, config),
+	});
+}

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/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/getTokenSuppliesMap.ts

@@ -0,0 +1,77 @@
+import type { GetTokenSuppliesMapArgs } from '@0xsequence/indexer';
+import { queryOptions } from '@tanstack/react-query';
+import type { SdkConfig } from '../../types';
+import {
+	collectableKeys,
+	getIndexerClient,
+	type ValuesOptional,
+} from '../_internal';
+import type { StandardQueryOptions } from '../types/query';
+
+export interface FetchGetTokenSuppliesMapParams
+	extends Omit<GetTokenSuppliesMapArgs, 'tokenMap'> {
+	chainId: number;
+	tokenIds: string[];
+	collectionAddress: string;
+	config: SdkConfig;
+}
+
+/**
+ * Fetches token supplies mapping from the indexer API
+ */
+export async function fetchGetTokenSuppliesMap(
+	params: FetchGetTokenSuppliesMapParams,
+) {
+	const { chainId, tokenIds, collectionAddress, config } = params;
+	const indexerClient = getIndexerClient(chainId, config);
+
+	const {
+		chainId: _,
+		tokenIds: __,
+		collectionAddress: ___,
+		config: ____,
+		...restParams
+	} = params;
+
+	return indexerClient.getTokenSuppliesMap({
+		tokenMap: {
+			[collectionAddress]: tokenIds,
+		},
+		includeMetadata: false,
+		...restParams,
+	});
+}
+
+export type GetTokenSuppliesMapQueryOptions =
+	ValuesOptional<FetchGetTokenSuppliesMapParams> & {
+		query?: StandardQueryOptions;
+	};
+
+export function getTokenSuppliesMapQueryOptions(
+	params: GetTokenSuppliesMapQueryOptions,
+) {
+	const enabled = Boolean(
+		params.chainId &&
+			params.tokenIds?.length &&
+			params.collectionAddress &&
+			params.config &&
+			(params.query?.enabled ?? true),
+	);
+
+	return queryOptions({
+		queryKey: [...collectableKeys.lists, 'tokenSuppliesMap', params],
+		queryFn: () =>
+			fetchGetTokenSuppliesMap({
+				// 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
+				tokenIds: params.tokenIds!,
+				// 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,12 @@
 export * from './balanceOfCollectible';
-export * from './getTokenSupplies';
-export * from './inventory';
-export * from './listCollectibles';
+export * from './collectible';
+export * from './collectionDetails';
+export * from './countOfPrimarySaleItems';
+export * from './floorOrder';
 export * from './highestOffer';
+export * from './inventory';
 export * from './listBalances';
-export * from './lowestListing';
+export * from './listCollectibles';
 export * from './listTokenMetadata';
+export * from './lowestListing';
 export * from './marketCurrencies';

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 {
@@ -259,7 +259,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 +268,8 @@ export async function fetchInventory(
 				includeEmpty: true,
 			},
 			side: OrderSide.listing,
+			config,
 		},
-		config,
 		marketplaceConfig,
 		page,
 	);

package/src/react/queries/listBalances.ts

@@ -2,7 +2,7 @@ import type { GetTokenBalancesReturn, Page } from '@0xsequence/indexer';
 import { infiniteQueryOptions } from '@tanstack/react-query';
 import type { 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;

package/src/react/queries/listCollectibleActivities.ts

@@ -0,0 +1,97 @@
+import { queryOptions } from '@tanstack/react-query';
+import type { Address } from 'viem';
+import type { Page, SdkConfig } from '../../types';
+import type {
+	ListCollectibleActivitiesArgs,
+	ListCollectibleActivitiesReturn,
+	SortBy,
+	ValuesOptional,
+} from '../_internal';
+import { collectableKeys, getMarketplaceClient } from '../_internal';
+import type { StandardQueryOptions } from '../types/query';
+
+export interface FetchListCollectibleActivitiesParams
+	extends Omit<
+		ListCollectibleActivitiesArgs,
+		'chainId' | 'contractAddress' | 'page'
+	> {
+	chainId: number;
+	collectionAddress: Address;
+	page?: number;
+	pageSize?: number;
+	sort?: SortBy[];
+	config: SdkConfig;
+}
+
+/**
+ * Fetches collectible activities from the Marketplace API
+ */
+export async function fetchListCollectibleActivities(
+	params: FetchListCollectibleActivitiesParams,
+): Promise<ListCollectibleActivitiesReturn> {
+	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: ListCollectibleActivitiesArgs = {
+		contractAddress: collectionAddress,
+		chainId: String(chainId),
+		page: pageParams,
+		...additionalApiParams,
+	};
+
+	return await marketplaceClient.listCollectibleActivities(apiArgs);
+}
+
+export type ListCollectibleActivitiesQueryOptions =
+	ValuesOptional<FetchListCollectibleActivitiesParams> & {
+		query?: StandardQueryOptions;
+	};
+
+export function listCollectibleActivitiesQueryOptions(
+	params: ListCollectibleActivitiesQueryOptions,
+) {
+	const enabled = Boolean(
+		params.collectionAddress &&
+			params.chainId &&
+			params.tokenId &&
+			params.config &&
+			(params.query?.enabled ?? true),
+	);
+
+	return queryOptions({
+		queryKey: [...collectableKeys.collectibleActivities, params],
+		queryFn: () =>
+			fetchListCollectibleActivities({
+				// 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
+				tokenId: params.tokenId!,
+				page: params.page,
+				pageSize: params.pageSize,
+				sort: params.sort,
+			}),
+		...params.query,
+		enabled,
+	});
+}