@0xsequence/marketplace-sdk 0.8.9 → 0.8.11

package/src/react/hooks/useFilters.tsx

@@ -1,39 +1,36 @@
 import type { PropertyFilter } from '@0xsequence/metadata';
 import { queryOptions, useQuery } from '@tanstack/react-query';
-import { z } from 'zod';
 import { FilterCondition, type SdkConfig } from '../../types';
 import { compareAddress } from '../../utils';
 import {
-	AddressSchema,
-	QueryArgSchema,
 	collectableKeys,
 	getMetadataClient,
 	getQueryClient,
 } from '../_internal';
+import { marketplaceConfigOptions } from '../queries/marketplaceConfig';
 import { useConfig } from './useConfig';
-import { marketplaceConfigOptions } from './useMarketplaceConfig';
 
-const UseFiltersSchema = z.object({
-	chainId: z.number(),
-	collectionAddress: AddressSchema,
-	showAllFilters: z.boolean().default(false).optional(),
-	query: QueryArgSchema,
-	excludePropertyValues: z.boolean().default(false).optional(),
-});
-
-export type UseFiltersArgs = z.infer<typeof UseFiltersSchema>;
+export type UseFiltersArgs = {
+	chainId: number;
+	collectionAddress: string;
+	showAllFilters?: boolean;
+	excludePropertyValues?: boolean;
+	query?: {
+		enabled?: boolean;
+	};
+};
 
 export type UseFilterReturn = Awaited<ReturnType<typeof fetchFilters>>;
 
 export const fetchFilters = async (args: UseFiltersArgs, config: SdkConfig) => {
-	const parsedArgs = UseFiltersSchema.parse(args);
+	const parsedArgs = args;
 	const metadataClient = getMetadataClient(config);
 
 	const filters = await metadataClient
 		.getTokenMetadataPropertyFilters({
 			chainID: parsedArgs.chainId.toString(),
 			contractAddress: parsedArgs.collectionAddress,
-			excludeProperties: [], // TODO: We can leverage this for some of the exclusion logic
+			excludeProperties: [],
 			excludePropertyValues: parsedArgs.excludePropertyValues,
 		})
 		.then((resp) => resp.filters);
@@ -44,8 +41,8 @@ export const fetchFilters = async (args: UseFiltersArgs, config: SdkConfig) => {
 	const marketplaceConfig = await queryClient.fetchQuery(
 		marketplaceConfigOptions(config),
 	);
-	const collectionFilters = marketplaceConfig.collections.find((c) =>
-		compareAddress(c.address, parsedArgs.collectionAddress),
+	const collectionFilters = marketplaceConfig.market.collections.find((c) =>
+		compareAddress(c.itemsAddress, parsedArgs.collectionAddress),
 	)?.filterSettings;
 
 	if (
@@ -58,7 +55,6 @@ export const fetchFilters = async (args: UseFiltersArgs, config: SdkConfig) => {
 
 	const { filterOrder, exclusions } = collectionFilters;
 
-	// Sort the filters based on the filterOrder, the filters that are not in the filterOrder are at the end
 	const sortedFilters = filters.toSorted((a, b) => {
 		const aIndex =
 			filterOrder.indexOf(a.name) > -1
@@ -73,17 +69,14 @@ export const fetchFilters = async (args: UseFiltersArgs, config: SdkConfig) => {
 
 	const filteredResults = sortedFilters.reduce<PropertyFilter[]>(
 		(acc, filter) => {
-			// Check if this filter should be excluded
 			const exclusionRule = exclusions.find((rule) => rule.key === filter.name);
 
 			if (!exclusionRule) {
-				// No exclusion rule, include the filter
 				acc.push(filter);
 				return acc;
 			}
 
 			if (exclusionRule.condition === FilterCondition.ENTIRE_KEY) {
-				// Skip this filter entirely
 				return acc;
 			}
 
@@ -91,7 +84,6 @@ export const fetchFilters = async (args: UseFiltersArgs, config: SdkConfig) => {
 				exclusionRule.condition === FilterCondition.SPECIFIC_VALUE &&
 				exclusionRule.value
 			) {
-				// Filter out specific values while keeping the filter
 				const filteredValues =
 					filter.values?.filter((value) => value !== exclusionRule.value) || [];
 				if (filteredValues.length > 0) {

package/src/react/hooks/useGetTokenSuppliesMap.ts

@@ -0,0 +1,28 @@
+import { useQuery } from '@tanstack/react-query';
+
+import { useConfig } from '..';
+import { getIndexerClient } from '../_internal';
+
+export const useGetTokenSuppliesMap = ({
+	chainId,
+	tokenIds,
+	collectionAddress,
+}: {
+	chainId: number;
+	tokenIds: string[];
+	collectionAddress: string;
+}) => {
+	const config = useConfig();
+	const indexerClient = getIndexerClient(chainId, config);
+	return useQuery({
+		queryKey: ['indexer-tokenSupplies', tokenIds, collectionAddress, chainId],
+		queryFn: () => {
+			return indexerClient.getTokenSuppliesMap({
+				tokenMap: {
+					[collectionAddress]: tokenIds,
+				},
+				includeMetadata: false,
+			});
+		},
+	});
+};

package/src/react/hooks/useInventory.tsx

@@ -1,4 +1,5 @@
 import { useInfiniteQuery } from '@tanstack/react-query';
+import { ContractType } from '../../types/api-types';
 import { type UseInventoryArgs, inventoryOptions } from '../queries/inventory';
 import { useConfig } from './useConfig';
 import { useMarketplaceConfig } from './useMarketplaceConfig';
@@ -7,9 +8,9 @@ export function useInventory(args: UseInventoryArgs) {
 	const config = useConfig();
 	const marketplaceConfig = useMarketplaceConfig();
 	const isLaos721 =
-		marketplaceConfig.data?.collections.find(
-			(c) => c.address === args.collectionAddress,
-		)?.isLAOSERC721 ?? false;
+		marketplaceConfig.data?.market.collections.find(
+			(c) => c.itemsAddress === args.collectionAddress,
+		)?.contractType === ContractType.LAOSERC721;
 
 	return useInfiniteQuery(inventoryOptions({ ...args, isLaos721 }, config));
 }

package/src/react/hooks/useList1155SaleSupplies.tsx

@@ -0,0 +1,62 @@
+import { getUnixTime } from 'date-fns';
+import type { Address } from 'viem';
+import { useReadContracts } from 'wagmi';
+import { ERC1155_SALES_CONTRACT_ABI } from '../..';
+
+interface UseSaleSupplyDataProps {
+	tokenIds: string[];
+	salesContractAddress: Address;
+}
+
+export function useList1155SaleSupplies({
+	tokenIds,
+	salesContractAddress,
+}: UseSaleSupplyDataProps) {
+	const getReadContractsArgs = (tokenIds: string[]) =>
+		tokenIds.map((tokenId) => ({
+			address: salesContractAddress,
+			abi: ERC1155_SALES_CONTRACT_ABI,
+			functionName: 'tokenSaleDetails',
+			args: [tokenId],
+		}));
+
+	const {
+		data: supplyData,
+		isLoading: supplyDataLoading,
+		error: supplyDataError,
+	} = useReadContracts({
+		batchSize: 500_000, // Node gateway limit has a limit of 512kB, setting it to 500kB to be safe
+		contracts: getReadContractsArgs(tokenIds),
+	});
+
+	const extendedSupplyData = (supplyData || [])
+		.map((data, index) => ({
+			...data,
+			tokenId: tokenIds[index],
+		}))
+		.filter((data) => data.status === 'success')
+		.filter((data) => {
+			if (typeof data.result !== 'object') return false;
+			const now = BigInt(getUnixTime(new Date()));
+			return data.result.endTime > now && data.result.startTime < now;
+		});
+
+	const getSupply = (tokenId: string): number | undefined => {
+		const found = extendedSupplyData.find((data) => data.tokenId === tokenId);
+		if (!found || typeof found.result !== 'object' || found.result === null)
+			return undefined;
+		const supply = found.result.supplyCap;
+		if (supply === undefined) return undefined;
+		// https://github.com/0xsequence/contracts-library/blob/ead1baf34270c76260d01cfc130bb7cc9d57518e/src/tokens/ERC1155/utility/sale/IERC1155Sale.sol#L8
+		// 0 means infinite
+		if (supply === 0n) return Number.POSITIVE_INFINITY;
+		return Number(supply);
+	};
+
+	return {
+		extendedSupplyData,
+		getSupply,
+		supplyDataLoading,
+		supplyDataError,
+	};
+}

package/src/react/hooks/useListBalances.tsx

@@ -1,4 +1,5 @@
 import { useInfiniteQuery } from '@tanstack/react-query';
+import { ContractType } from '../../types/api-types';
 import { listBalancesOptions } from '../queries/listBalances';
 import type { UseListBalancesArgs } from '../queries/listBalances';
 import { useConfig } from './useConfig';
@@ -27,9 +28,10 @@ export function useListBalances(args: UseListBalancesArgs) {
 	const config = useConfig();
 	const { data: marketplaceConfig } = useMarketplaceConfig();
 
-	const isLaos721 = marketplaceConfig?.collections.find(
-		(collection) => collection.address === args.contractAddress,
-	)?.isLAOSERC721;
+	const isLaos721 =
+		marketplaceConfig?.market.collections.find(
+			(collection) => collection.itemsAddress === args.contractAddress,
+		)?.contractType === ContractType.LAOSERC721;
 
 	if (isLaos721) {
 		args.isLaos721 = true;

package/src/react/hooks/useListCollectibles.tsx

@@ -1,4 +1,5 @@
 import { useInfiniteQuery } from '@tanstack/react-query';
+import { ContractType } from '../../types/api-types';
 import { listCollectiblesOptions } from '../queries/listCollectibles';
 import type { UseListCollectiblesArgs } from '../queries/listCollectibles';
 import { useConfig } from './useConfig';
@@ -27,9 +28,10 @@ export function useListCollectibles(args: UseListCollectiblesArgs) {
 	const config = useConfig();
 	const { data: marketplaceConfig } = useMarketplaceConfig();
 
-	const isLaos721 = marketplaceConfig?.collections.find(
-		(collection) => collection.address === args.collectionAddress,
-	)?.isLAOSERC721;
+	const isLaos721 =
+		marketplaceConfig?.market.collections.find(
+			(collection) => collection.itemsAddress === args.collectionAddress,
+		)?.contractType === ContractType.LAOSERC721;
 
 	if (isLaos721) {
 		args.isLaos721 = true;

package/src/react/hooks/useListCollections.tsx

@@ -1,88 +1,26 @@
-import { queryOptions, useQuery } from '@tanstack/react-query';
-import { z } from 'zod';
-import type { MarketplaceConfig, SdkConfig } from '../../types';
-import {
-	QueryArgSchema,
-	collectionKeys,
-	getMetadataClient,
-} from '../_internal';
+import { useQuery } from '@tanstack/react-query';
+import type { MarketplaceType } from '../../types/new-marketplace-types';
+import { listCollectionsOptions } from '../queries/listCollections';
 import { useConfig } from './useConfig';
 import { useMarketplaceConfig } from './useMarketplaceConfig';
 
-const UseListCollectionsSchema = z.object({
-	query: QueryArgSchema.optional().default({}),
-});
-
-export type UseListCollectionsArgs = z.input<typeof UseListCollectionsSchema>;
-
-export type UseListCollectionsReturn = Awaited<
-	ReturnType<typeof fetchListCollections>
->;
-
-type FetchListCollectionsArgs = {
-	marketplaceConfig: MarketplaceConfig;
-	query?: z.infer<typeof QueryArgSchema>;
-};
-
-const fetchListCollections = async (
-	{ marketplaceConfig }: FetchListCollectionsArgs,
-	config: SdkConfig,
-) => {
-	const metadataClient = getMetadataClient(config);
-
-	if (!marketplaceConfig?.collections?.length) {
-		return [];
-	}
-
-	// Group collections by chainId
-	const collectionsByChain = marketplaceConfig.collections.reduce<
-		Record<string, string[]>
-	>((acc, curr) => {
-		const { chainId, address } = curr;
-		if (!acc[chainId]) {
-			acc[chainId] = [];
-		}
-		acc[chainId].push(address);
-		return acc;
-	}, {});
-
-	// Fetch collections for each chain
-	const promises = Object.entries(collectionsByChain).map(
-		([chainId, addresses]) =>
-			metadataClient
-				.getContractInfoBatch({
-					chainID: chainId,
-					contractAddresses: addresses,
-				})
-				.then((resp) => Object.values(resp.contractInfoMap)),
-	);
-
-	const results = await Promise.all(promises);
-	return results.flat();
-};
-
-export const listCollectionsOptions = (
-	args: FetchListCollectionsArgs,
-	config: SdkConfig,
-) => {
-	return queryOptions({
-		...args.query,
-		queryKey: [...collectionKeys.list],
-		queryFn: () => fetchListCollections(args, config),
-	});
+type UseListCollectionsArgs = {
+	marketplaceType?: MarketplaceType;
+	query?: {
+		enabled?: boolean;
+	};
 };
 
 export const useListCollections = (args: UseListCollectionsArgs = {}) => {
 	const config = useConfig();
-	const { data: marketplaceConfig, isLoading: isLoadingConfig } =
-		useMarketplaceConfig();
+	const { data: marketplaceConfig } = useMarketplaceConfig();
 
 	return useQuery({
-		...listCollectionsOptions(
-			// biome-ignore lint/style/noNonNullAssertion: <explanation>
-			{ marketplaceConfig: marketplaceConfig!, query: args.query },
+		...args.query,
+		...listCollectionsOptions({
+			marketplaceType: args.marketplaceType,
+			marketplaceConfig,
 			config,
-		),
-		enabled: !isLoadingConfig && !!marketplaceConfig,
+		}),
 	});
 };

package/src/react/hooks/useListTokenMetadata.ts

@@ -0,0 +1,19 @@
+import { useQuery } from '@tanstack/react-query';
+import { useConfig } from './useConfig';
+
+import {
+	type FetchTokenMetadataArgs,
+	tokenMetadataOptions,
+} from '../queries/listTokenMetadata';
+
+export const useListTokenMetadata = (args: FetchTokenMetadataArgs) => {
+	const config = useConfig();
+	const { chainId, contractAddress, tokenIds, query } = args;
+
+	return useQuery({
+		...tokenMetadataOptions(
+			{ chainId, contractAddress, tokenIds, query },
+			config,
+		),
+	});
+};

package/src/react/hooks/useMarketCurrencies.tsx

@@ -0,0 +1,8 @@
+import { useQuery } from '@tanstack/react-query';
+import { type UseMarketCurrenciesArgs, currenciesOptions } from '../queries';
+import { useConfig } from './useConfig';
+
+export const useMarketCurrencies = (args: UseMarketCurrenciesArgs) => {
+	const config = useConfig();
+	return useQuery(currenciesOptions(args, config));
+};

package/src/react/hooks/useMarketplaceConfig.tsx

@@ -2,8 +2,6 @@ import { useQuery } from '@tanstack/react-query';
 import { marketplaceConfigOptions } from '../queries/marketplaceConfig';
 import { useConfig } from './useConfig';
 
-export * from '../queries/marketplaceConfig';
-
 export const useMarketplaceConfig = () => {
 	const config = useConfig();
 	return useQuery(marketplaceConfigOptions(config));

package/src/react/queries/index.ts

@@ -5,3 +5,5 @@ export * from './listCollectibles';
 export * from './highestOffer';
 export * from './listBalances';
 export * from './lowestListing';
+export * from './listTokenMetadata';
+export * from './marketCurrencies';

package/src/react/queries/inventory.ts

@@ -82,7 +82,7 @@ function collectibleFromTokenBalance(
 			audio: token.tokenMetadata?.audio,
 		},
 		contractInfo: token.contractInfo,
-		contractType: token.contractType as
+		contractType: token.contractType as unknown as
 			| ContractType.ERC1155
 			| ContractType.ERC721,
 		balance: token.balance,

package/src/react/queries/listCollections.ts

@@ -0,0 +1,118 @@
+import type { ContractInfo } from '@0xsequence/metadata';
+import { queryOptions, skipToken } from '@tanstack/react-query';
+import type { SdkConfig } from '../../types';
+import type {
+	MarketCollection,
+	MarketplaceConfig,
+	MarketplaceType,
+	ShopCollection,
+} from '../../types/new-marketplace-types';
+import { compareAddress } from '../../utils';
+import { collectionKeys, getMetadataClient } from '../_internal';
+
+const allCollections = (marketplaceConfig: MarketplaceConfig) => {
+	return [
+		...marketplaceConfig.market.collections,
+		...marketplaceConfig.shop.collections,
+	];
+};
+
+const fetchListCollections = async ({
+	marketplaceType,
+	marketplaceConfig,
+	config,
+}: {
+	marketplaceType?: MarketplaceType;
+	marketplaceConfig: MarketplaceConfig;
+	config: SdkConfig;
+}) => {
+	const metadataClient = getMetadataClient(config);
+
+	let collections = allCollections(marketplaceConfig);
+
+	if (!collections?.length) {
+		return [];
+	}
+
+	if (marketplaceType) {
+		collections = collections.filter(
+			(collection) => collection.marketplaceType === marketplaceType,
+		);
+	}
+
+	// Group collections by chainId
+	const collectionsByChain = collections.reduce<Record<string, string[]>>(
+		(acc, curr) => {
+			const { chainId, itemsAddress } = curr;
+			if (!acc[chainId]) {
+				acc[chainId] = [];
+			}
+			acc[chainId].push(itemsAddress);
+			return acc;
+		},
+		{},
+	);
+
+	// Fetch collections for each chain
+	const promises = Object.entries(collectionsByChain).map(
+		([chainId, addresses]) =>
+			metadataClient
+				.getContractInfoBatch({
+					chainID: chainId,
+					contractAddresses: addresses,
+				})
+				.then((resp) => Object.values(resp.contractInfoMap)),
+	);
+
+	const settled = await Promise.allSettled(promises);
+	const results = settled
+		.filter(
+			(r): r is PromiseFulfilledResult<ContractInfo[]> =>
+				r.status === 'fulfilled',
+		)
+		.flatMap((r) => r.value);
+
+	const collectionsWithMetadata = collections
+		.map((collection) => {
+			const metadata = results.find((result) =>
+				compareAddress(result.address, collection.itemsAddress),
+			);
+			return { collection, metadata };
+		})
+		.filter(
+			(
+				item,
+			): item is {
+				collection: MarketCollection | ShopCollection;
+				metadata: ContractInfo;
+			} => item.metadata !== undefined,
+		)
+		.map(({ collection, metadata }) => ({
+			...collection,
+			...metadata,
+		}));
+
+	return collectionsWithMetadata;
+};
+
+export const listCollectionsOptions = ({
+	marketplaceType,
+	marketplaceConfig,
+	config,
+}: {
+	marketplaceType?: MarketplaceType;
+	marketplaceConfig: MarketplaceConfig | undefined;
+	config: SdkConfig;
+}) => {
+	return queryOptions({
+		queryKey: [...collectionKeys.list, marketplaceType],
+		queryFn: marketplaceConfig
+			? () =>
+					fetchListCollections({
+						marketplaceType,
+						marketplaceConfig,
+						config,
+					})
+			: skipToken,
+	});
+};

package/src/react/queries/listTokenMetadata.ts

@@ -0,0 +1,38 @@
+import { queryOptions } from '@tanstack/react-query';
+import type { SdkConfig } from '../../types';
+import { getMetadataClient } from '../_internal';
+
+export interface FetchTokenMetadataArgs {
+	chainId: number;
+	contractAddress: string;
+	tokenIds: string[];
+	query?: {
+		enabled?: boolean;
+	};
+}
+
+const fetchTokenMetadata = async (
+	{ chainId, contractAddress, tokenIds }: FetchTokenMetadataArgs,
+	config: SdkConfig,
+) => {
+	const metadataClient = getMetadataClient(config);
+
+	const response = await metadataClient.getTokenMetadata({
+		chainID: chainId.toString(),
+		contractAddress: contractAddress,
+		tokenIDs: tokenIds,
+	});
+
+	return response.tokenMetadata;
+};
+
+export const tokenMetadataOptions = (
+	args: FetchTokenMetadataArgs,
+	config: SdkConfig,
+) => {
+	return queryOptions({
+		...args.query,
+		queryKey: ['listTokenMetadata', args.chainId, args.contractAddress],
+		queryFn: () => fetchTokenMetadata(args, config),
+	});
+};

package/src/react/queries/marketCurrencies.ts

@@ -0,0 +1,77 @@
+import { queryOptions } from '@tanstack/react-query';
+import { type Address, zeroAddress } from 'viem';
+import type { SdkConfig } from '../../types';
+import { compareAddress } from '../../utils';
+import {
+	currencyKeys,
+	getMarketplaceClient,
+	getQueryClient,
+} from '../_internal';
+import { marketplaceConfigOptions } from './marketplaceConfig';
+
+type QueryArg = {
+	enabled?: boolean;
+};
+
+export interface UseMarketCurrenciesArgs {
+	chainId: number;
+	includeNativeCurrency?: boolean;
+	collectionAddress?: Address;
+	query?: QueryArg;
+}
+
+const fetchMarketCurrencies = async (
+	args: UseMarketCurrenciesArgs,
+	config: SdkConfig,
+) => {
+	const includeNativeCurrency = args.includeNativeCurrency ?? true;
+	const marketplaceClient = getMarketplaceClient(args.chainId, config);
+
+	let currencies = await marketplaceClient.listCurrencies().then((resp) =>
+		resp.currencies.map((currency) => ({
+			...currency,
+			contractAddress: currency.contractAddress || zeroAddress,
+		})),
+	);
+
+	if (args.collectionAddress) {
+		const queryClient = getQueryClient();
+		const marketplaceConfig = await queryClient.fetchQuery(
+			marketplaceConfigOptions(config),
+		);
+
+		const currenciesOptions = marketplaceConfig.market.collections.find(
+			(collection) =>
+				compareAddress(collection.itemsAddress, args.collectionAddress),
+		)?.currencyOptions;
+
+		// Filter currencies based on collection currency options
+		if (currenciesOptions) {
+			currencies = currencies.filter((currency) =>
+				currenciesOptions.includes(currency.contractAddress),
+			);
+		}
+	}
+
+	if (!includeNativeCurrency) {
+		currencies = currencies.filter((currency) => !currency.nativeCurrency);
+	}
+
+	return currencies;
+};
+
+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),
+	});
+};