@0xsequence/marketplace-sdk 0.8.11 → 0.9.0

package/src/react/queries/listCollections.ts

@@ -1,14 +1,18 @@
 import type { ContractInfo } from '@0xsequence/metadata';
 import { queryOptions, skipToken } from '@tanstack/react-query';
-import type { SdkConfig } from '../../types';
+import type { MarketplaceType, SdkConfig } from '../../types';
 import type {
 	MarketCollection,
 	MarketplaceConfig,
-	MarketplaceType,
 	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 [
@@ -17,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);
@@ -65,6 +71,13 @@ const fetchListCollections = async ({
 	);
 
 	const settled = await Promise.allSettled(promises);
+
+	// If all promises failed, throw the first error
+	if (settled.every((result) => result.status === 'rejected')) {
+		const firstError = settled[0] as PromiseRejectedResult;
+		throw firstError.reason;
+	}
+
 	const results = settled
 		.filter(
 			(r): r is PromiseFulfilledResult<ContractInfo[]> =>
@@ -93,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,15 +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],
-		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,
 	});
-};
+}

package/src/react/queries/lowestListing.ts

@@ -1,52 +1,69 @@
 import { queryOptions } from '@tanstack/react-query';
-import type { Address } from 'viem';
 import type { SdkConfig } from '../../types';
 import {
+	collectableKeys,
 	type GetCollectibleLowestListingArgs,
 	type GetCollectibleLowestListingReturn,
-	collectableKeys,
 	getMarketplaceClient,
+	type ValuesOptional,
 } from '../_internal';
+import type { StandardQueryOptions } from '../types/query';
 
-export interface UseLowestListingArgs
-	extends Omit<GetCollectibleLowestListingArgs, 'contractAddress'> {
-	collectionAddress: Address;
+export interface FetchLowestListingParams
+	extends Omit<GetCollectibleLowestListingArgs, 'contractAddress' | 'chainId'> {
+	collectionAddress: string;
 	chainId: number;
-	query?: {
-		enabled?: boolean;
-	};
+	config: SdkConfig;
 }
 
+/**
+ * Fetches the lowest listing for a collectible from the marketplace API
+ */
 export async function fetchLowestListing(
-	args: UseLowestListingArgs,
-	config: SdkConfig,
+	params: FetchLowestListingParams,
 ): Promise<GetCollectibleLowestListingReturn['order'] | null> {
-	const marketplaceClient = getMarketplaceClient(args.chainId, config);
+	const { collectionAddress, chainId, config, ...additionalApiParams } = params;
 
-	const data = await marketplaceClient.getCollectibleLowestListing({
-		contractAddress: args.collectionAddress,
-		...args,
-	});
+	const marketplaceClient = getMarketplaceClient(config);
 
-	// let order: Order | undefined;
-	// if (data.order) {
-	// 	order = {
-	// 		...data.order,
-	// 		priceAmount: BigInt(data.order.priceAmount),
-	// 		priceAmountNet: BigInt(data.order.priceAmountNet),
-	// 	};
-	// }
+	const apiArgs: GetCollectibleLowestListingArgs = {
+		contractAddress: collectionAddress,
+		chainId: String(chainId),
+		...additionalApiParams,
+	};
 
-	return data.order || null;
+	const result = await marketplaceClient.getCollectibleLowestListing(apiArgs);
+	return result.order || null;
 }
 
-export function lowestListingOptions(
-	args: UseLowestListingArgs,
-	config: SdkConfig,
-) {
+export type LowestListingQueryOptions =
+	ValuesOptional<FetchLowestListingParams> & {
+		query?: StandardQueryOptions;
+	};
+
+export function lowestListingQueryOptions(params: LowestListingQueryOptions) {
+	const enabled = Boolean(
+		params.collectionAddress &&
+			params.chainId &&
+			params.tokenId &&
+			params.config &&
+			(params.query?.enabled ?? true),
+	);
+
 	return queryOptions({
-		enabled: args.query?.enabled ?? true,
-		queryKey: [...collectableKeys.lowestListings, args],
-		queryFn: () => fetchLowestListing(args, config),
+		queryKey: [...collectableKeys.lowestListings, params],
+		queryFn: () =>
+			fetchLowestListing({
+				// 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/marketCurrencies.ts

@@ -6,35 +6,40 @@ import {
 	currencyKeys,
 	getMarketplaceClient,
 	getQueryClient,
+	type ValuesOptional,
 } from '../_internal';
+import type { StandardQueryOptions } from '../types/query';
 import { marketplaceConfigOptions } from './marketplaceConfig';
 
-type QueryArg = {
-	enabled?: boolean;
-};
-
-export interface UseMarketCurrenciesArgs {
+export interface FetchMarketCurrenciesParams {
 	chainId: number;
 	includeNativeCurrency?: boolean;
 	collectionAddress?: Address;
-	query?: QueryArg;
+	config: SdkConfig;
 }
 
-const fetchMarketCurrencies = async (
-	args: UseMarketCurrenciesArgs,
-	config: SdkConfig,
-) => {
-	const includeNativeCurrency = args.includeNativeCurrency ?? true;
-	const marketplaceClient = getMarketplaceClient(args.chainId, config);
+/**
+ * Fetches supported currencies for a marketplace
+ */
+export async function fetchMarketCurrencies(
+	params: FetchMarketCurrenciesParams,
+) {
+	const { chainId, includeNativeCurrency, collectionAddress, config } = params;
+	const includeNativeCurrencyOption = includeNativeCurrency ?? true;
+	const marketplaceClient = getMarketplaceClient(config);
 
-	let currencies = await marketplaceClient.listCurrencies().then((resp) =>
-		resp.currencies.map((currency) => ({
-			...currency,
-			contractAddress: currency.contractAddress || zeroAddress,
-		})),
-	);
+	let currencies = await marketplaceClient
+		.listCurrencies({
+			chainId: String(chainId),
+		})
+		.then((resp) =>
+			resp.currencies.map((currency) => ({
+				...currency,
+				contractAddress: currency.contractAddress || zeroAddress,
+			})),
+		);
 
-	if (args.collectionAddress) {
+	if (collectionAddress) {
 		const queryClient = getQueryClient();
 		const marketplaceConfig = await queryClient.fetchQuery(
 			marketplaceConfigOptions(config),
@@ -42,7 +47,7 @@ const fetchMarketCurrencies = async (
 
 		const currenciesOptions = marketplaceConfig.market.collections.find(
 			(collection) =>
-				compareAddress(collection.itemsAddress, args.collectionAddress),
+				compareAddress(collection.itemsAddress, collectionAddress),
 		)?.currencyOptions;
 
 		// Filter currencies based on collection currency options
@@ -53,25 +58,37 @@ const fetchMarketCurrencies = async (
 		}
 	}
 
-	if (!includeNativeCurrency) {
+	if (!includeNativeCurrencyOption) {
 		currencies = currencies.filter((currency) => !currency.nativeCurrency);
 	}
 
 	return currencies;
-};
+}
+
+export type MarketCurrenciesQueryOptions =
+	ValuesOptional<FetchMarketCurrenciesParams> & {
+		query?: StandardQueryOptions;
+	};
+
+export function marketCurrenciesQueryOptions(
+	params: MarketCurrenciesQueryOptions,
+) {
+	const enabled = Boolean(
+		params.chainId && params.config && (params.query?.enabled ?? true),
+	);
 
-export const currenciesOptions = (
-	args: UseMarketCurrenciesArgs,
-	config: SdkConfig,
-) => {
 	return queryOptions({
-		...args.query,
-		queryKey: [
-			...currencyKeys.lists,
-			args.chainId,
-			args.includeNativeCurrency ?? true,
-			args.collectionAddress,
-		],
-		queryFn: () => fetchMarketCurrencies(args, config),
+		queryKey: [...currencyKeys.lists, params],
+		queryFn: () =>
+			fetchMarketCurrencies({
+				// 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
+				config: params.config!,
+				includeNativeCurrency: params.includeNativeCurrency,
+				collectionAddress: params.collectionAddress,
+			}),
+		...params.query,
+		enabled,
 	});
-};
+}

package/src/react/queries/marketplaceConfig.ts

@@ -1,129 +1,104 @@
 import { queryOptions } from '@tanstack/react-query';
-import type { ContractType, Env, SdkConfig, ShopConfig } from '../../types';
-import {
-	type MarketCollection,
-	type MarketPage,
-	type MarketplaceConfig,
-	MarketplaceType,
-	type NewMarketplaceSettings,
-	type ShopCollection,
-	type ShopPage,
+import type { ContractType, SdkConfig } from '../../types';
+import type {
+	MarketCollection,
+	MarketPage,
+	MarketplaceConfig,
+	ShopCollection,
+	ShopPage,
 } from '../../types/new-marketplace-types';
-import { builderRpcApi, configKeys } from '../_internal';
-import { BuilderAPI } from '../_internal/api/builder-api';
+import { configKeys, getBuilderClient } from '../_internal';
 import type { LookupMarketplaceReturn } from '../_internal/api/builder.gen';
 
 export const fetchMarketplaceConfig = async ({
-	projectId,
-	projectAccessKey,
-	env,
+	config,
 	prefetchedMarketplaceSettings,
-	tmpShopConfig,
 }: {
-	projectId: string;
-	projectAccessKey: string;
-	env: Env;
-	tmpShopConfig?: ShopConfig;
-	prefetchedMarketplaceSettings?: LookupMarketplaceReturn; //TODO: Is this the right approach?
+	config: SdkConfig;
+	prefetchedMarketplaceSettings?: LookupMarketplaceReturn;
 }): Promise<MarketplaceConfig> => {
 	let builderMarketplaceConfig = prefetchedMarketplaceSettings;
+
 	if (!builderMarketplaceConfig) {
-		const baseUrl = builderRpcApi(env);
-		const builderApi = new BuilderAPI(baseUrl, projectAccessKey);
+		const builderApi = getBuilderClient(config);
 		const response = await builderApi.lookupMarketplace({
-			projectId: Number(projectId),
+			projectId: Number(config.projectId),
 		});
 
 		builderMarketplaceConfig = response;
 	}
-	const settings = {
-		publisherId: builderMarketplaceConfig.marketplace.settings.publisherId,
-		title: builderMarketplaceConfig.marketplace.settings.title,
-		socials: builderMarketplaceConfig.marketplace.settings.socials,
-		faviconUrl: builderMarketplaceConfig.marketplace.settings.faviconUrl,
-		walletOptions: builderMarketplaceConfig.marketplace.settings.walletOptions,
-		logoUrl: builderMarketplaceConfig.marketplace.settings.logoUrl,
-		fontUrl: builderMarketplaceConfig.marketplace.settings.fontUrl,
-		accessKey: builderMarketplaceConfig.marketplace.settings.accessKey,
-	} satisfies NewMarketplaceSettings;
 
 	const marketCollections = (
 		builderMarketplaceConfig.marketCollections ?? []
 	).map((collection) => {
 		return {
-			chainId: collection.chainId,
-			bannerUrl: collection.bannerUrl,
+			...collection,
 			contractType: collection.contractType as ContractType,
-			marketplaceType: MarketplaceType.MARKET,
-			itemsAddress: collection.itemsAddress,
-			feePercentage: collection.feePercentage,
-			currencyOptions: collection.currencyOptions,
-			filterSettings: collection.filterSettings,
-			destinationMarketplace: collection.destinationMarketplace,
+			marketplaceType: 'market',
 		} satisfies MarketCollection;
 	});
 
-	const shopCollections = tmpShopConfig?.collections.map((collection) => {
-		return {
-			chainId: collection.chainId,
-			bannerUrl: collection.bannerUrl,
-			contractType: collection.contractType,
-			marketplaceType: MarketplaceType.SHOP,
-			itemsAddress: collection.address,
-			filterSettings: undefined,
-			saleAddress: collection.primarySalesContractAddress,
-		} satisfies ShopCollection;
-	});
+	const shopCollections = builderMarketplaceConfig.shopCollections.map(
+		(collection) => {
+			return {
+				...collection,
+				marketplaceType: 'shop',
+			} satisfies ShopCollection;
+		},
+	);
 
 	const market = {
-		enabled: true,
-		bannerUrl: builderMarketplaceConfig.marketplace.market.bannerUrl,
-		ogImage: builderMarketplaceConfig.marketplace.market.ogImage,
+		...builderMarketplaceConfig.marketplace.market,
 		collections: marketCollections,
 	} satisfies MarketPage;
 
 	const shop = {
-		enabled: tmpShopConfig !== undefined,
-		bannerUrl: tmpShopConfig?.bannerUrl ?? '',
-		ogImage: tmpShopConfig?.ogImage,
+		...builderMarketplaceConfig.marketplace.shop,
 		collections: shopCollections ?? [],
 	} satisfies ShopPage;
 
-	return {
-		projectId: Number(projectId),
-		settings,
+	let marketplaceConfig = {
+		projectId: Number(config.projectId),
+		settings: builderMarketplaceConfig.marketplace.settings,
 		market,
 		shop,
 	} satisfies MarketplaceConfig;
-};
 
-export const marketplaceConfigOptions = (config: SdkConfig) => {
-	let env: Env = 'production';
-	if ('_internal' in config && config._internal !== undefined) {
-		env = config._internal.builderEnv ?? env;
+	if (config._internal?.overrides?.marketplaceConfig) {
+		const overrides = config._internal.overrides.marketplaceConfig;
+		marketplaceConfig = {
+			...marketplaceConfig,
+			...overrides,
+			market: {
+				...marketplaceConfig.market,
+				...overrides.market,
+				//@ts-expect-error - TODO: Fix this partial type. We need to align new-marketplace-types with builder.gen.ts
+				collections:
+					overrides.market?.collections ?? marketplaceConfig.market.collections,
+			},
+			shop: {
+				...marketplaceConfig.shop,
+				...overrides.shop,
+				//@ts-expect-error - TODO: Fix this partial type. We need to align new-marketplace-types with builder.gen.ts
+				collections:
+					overrides.shop?.collections ?? marketplaceConfig.shop.collections,
+			},
+		};
 	}
 
-	let prefetchedMarketplaceSettings: LookupMarketplaceReturn | undefined;
-	if (
-		'_internal' in config &&
-		config._internal?.prefetchedMarketplaceSettings
-	) {
-		prefetchedMarketplaceSettings =
-			config._internal.prefetchedMarketplaceSettings;
-	}
+	return marketplaceConfig;
+};
 
-	const projectId = config.projectId;
-	const projectAccessKey = config.projectAccessKey;
+export const marketplaceConfigOptions = (config: SdkConfig) => {
+	const prefetchedMarketplaceSettings =
+		config._internal?.prefetchedMarketplaceSettings;
 
 	return queryOptions({
-		queryKey: [...configKeys.marketplace, env, projectId],
+		queryKey: [...configKeys.marketplace],
 		queryFn: () =>
 			fetchMarketplaceConfig({
-				env,
-				projectId,
-				projectAccessKey,
+				config,
 				prefetchedMarketplaceSettings,
-				tmpShopConfig: config.tmpShopConfig,
 			}),
 	});
 };