@0xsequence/marketplace-sdk 0.8.11 → 0.9.0

package/src/react/queries/inventory.ts

@@ -10,8 +10,10 @@ import {
 	type CollectibleOrder,
 	type ContractType,
 	getIndexerClient,
+	LaosAPI,
 } from '../_internal';
-import { fetchCollectibles } from './listCollectibles';
+import { fetchListCollectibles } from './listCollectibles';
+import { fetchMarketplaceConfig } from './marketplaceConfig';
 
 export interface UseInventoryArgs {
 	accountAddress: Address;
@@ -95,7 +97,37 @@ async function fetchAllIndexerTokens(
 	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,
+			page: {
+				sort: [
+					{
+						column: 'CREATED_AT',
+						order: 'DESC',
+					},
+				],
+			},
+		});
+
+		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 = {
@@ -216,6 +248,7 @@ export async function fetchInventory(
 			collectionAddress,
 			config,
 			state,
+			isLaos721,
 		);
 	}
 
@@ -225,7 +258,8 @@ export async function fetchInventory(
 	}
 
 	// Fetch collectibles from marketplace API
-	const collectibles = await fetchCollectibles(
+	const marketplaceConfig = await fetchMarketplaceConfig({ config });
+	const collectibles = await fetchListCollectibles(
 		{
 			chainId,
 			collectionAddress,
@@ -234,9 +268,9 @@ export async function fetchInventory(
 				includeEmpty: true,
 			},
 			side: OrderSide.listing,
-			isLaos721,
+			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 { balanceQueries, getIndexerClient } from '../_internal';
+import { balanceQueries, getIndexerClient, LaosAPI } from '../_internal';
 
 export type UseListBalancesArgs = {
 	chainId: number;
@@ -29,37 +29,21 @@ export async function fetchBalances(
 	config: SdkConfig,
 	page: Page,
 ): Promise<GetTokenBalancesReturn> {
-	if (args.isLaos721) {
-		const response = await fetch(
-			'https://extensions.api.laosnetwork.io/token/GetTokenBalances',
-			{
-				method: 'POST',
-				headers: {
-					'Content-Type': 'application/json',
-				},
-				body: JSON.stringify({
-					chainId: args.chainId.toString(),
-					accountAddress: args.accountAddress,
-					contractAddress: args.contractAddress,
-					includeMetadata: args.includeMetadata ?? true,
-					page: {
-						sort: [
-							{
-								column: 'CREATED_AT',
-								order: 'DESC',
-							},
-						],
+	if (args.isLaos721 && args.accountAddress) {
+		const laosClient = new LaosAPI();
+		return laosClient.getTokenBalances({
+			chainId: args.chainId.toString(),
+			accountAddress: args.accountAddress,
+			includeMetadata: args.includeMetadata,
+			page: {
+				sort: [
+					{
+						column: 'CREATED_AT',
+						order: 'DESC',
 					},
-				}),
+				],
 			},
-		);
-
-		if (!response.ok) {
-			throw new Error(`Laos API request failed with status ${response.status}`);
-		}
-
-		// TODO: This is pretty unsafe, we should validate the response
-		return response.json() as Promise<GetTokenBalancesReturn>;
+		});
 	}
 
 	const indexerClient = getIndexerClient(args.chainId, config);

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,
+	});
+}

package/src/react/queries/listCollectibles.ts

@@ -1,52 +1,93 @@
 import { infiniteQueryOptions } from '@tanstack/react-query';
-import type { Address, Hex } from 'viem';
-import type { Page, SdkConfig } from '../../types';
+import type { Address } from 'viem';
+import type { MarketplaceConfig, Page, SdkConfig } from '../../types';
+import type { MarketplaceType } from '../../types/types';
+import { compareAddress } from '../../utils';
 import type {
-	CollectibleOrder,
-	CollectiblesFilter,
 	ListCollectiblesArgs,
 	ListCollectiblesReturn,
+	ValuesOptional,
 } from '../_internal';
-import { OrderSide, collectableKeys, getMarketplaceClient } from '../_internal';
-import { type UseListBalancesArgs, fetchBalances } from './listBalances';
-export type UseListCollectiblesArgs = {
-	collectionAddress: Hex;
+import {
+	type CollectibleOrder,
+	collectableKeys,
+	getMarketplaceClient,
+	OrderSide,
+} from '../_internal';
+import { fetchMarketplaceConfig } from '../queries/marketplaceConfig';
+import type { StandardInfiniteQueryOptions } from '../types/query';
+import { fetchBalances, type UseListBalancesArgs } from './listBalances';
+
+export interface FetchListCollectiblesParams
+	extends Omit<ListCollectiblesArgs, 'chainId' | 'contractAddress'> {
 	chainId: number;
-	side: OrderSide;
-	filter?: CollectiblesFilter;
+	collectionAddress: Address;
 	isLaos721?: boolean;
-	query?: {
-		enabled?: boolean;
-	};
-};
+	marketplaceType?: MarketplaceType;
+	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 marketplaceClient = getMarketplaceClient(args.chainId, config);
-	const parsedArgs = {
-		...args,
-		contractAddress: args.collectionAddress,
+	const { collectionAddress, chainId, config, ...additionalApiParams } = params;
+	const marketplaceClient = getMarketplaceClient(config);
+
+	const apiArgs: ListCollectiblesArgs = {
+		contractAddress: collectionAddress,
+		chainId: String(chainId),
 		page: page,
-		side: args.side,
-	} satisfies ListCollectiblesArgs;
+		...additionalApiParams,
+	};
 
-	if (args.isLaos721 && args.side === OrderSide.listing) {
+	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 = {
-				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,
@@ -80,26 +121,55 @@ export async function fetchCollectibles(
 			console.error(error);
 		}
 	}
-	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],
-		queryFn: ({ pageParam }) => fetchCollectibles(args, config, pageParam),
+		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
+					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,
+	});
+}