@0xsequence/marketplace-sdk 0.0.1

package/src/react/hooks/useCollectionCounts.tsx

@@ -0,0 +1,61 @@
+import {
+	type ChainId,
+	type CollectiblesFilter,
+	type OrderSide,
+	type QueryArg,
+	collectableKeys,
+	getMarketplaceClient,
+} from '@internal';
+import { queryOptions, useQuery } from '@tanstack/react-query';
+import type { SdkConfig } from '@types';
+import { useConfig } from './useConfig';
+
+type ExtendedCollectiblesFilter = { side: OrderSide } & CollectiblesFilter;
+
+export type UseCountOfCollectablesArgs = {
+	collectionAddress: string;
+	chainId: ChainId;
+	filter?: ExtendedCollectiblesFilter;
+} & QueryArg;
+
+export type UseHighestOfferReturn = ReturnType<typeof fetchCountOfCollectables>;
+
+const fetchCountOfCollectables = async (
+	args: UseCountOfCollectablesArgs,
+	config: SdkConfig,
+) => {
+	const marketplaceClient = getMarketplaceClient(args.chainId, config);
+	if (args.filter) {
+		return marketplaceClient
+			.getCountOfFilteredCollectibles({
+				...args,
+				contractAddress: args.collectionAddress,
+				side: args.filter.side,
+			})
+			.then((resp) => resp.count);
+		// biome-ignore lint/style/noUselessElse: <explanation>
+	} else {
+		return marketplaceClient
+			.getCountOfAllCollectibles({
+				...args,
+				contractAddress: args.collectionAddress,
+			})
+			.then((resp) => resp.count);
+	}
+};
+
+export const countOfCollectablesOptions = (
+	args: UseCountOfCollectablesArgs,
+	config: SdkConfig,
+) => {
+	return queryOptions({
+		...args.query,
+		queryKey: [...collectableKeys.counts, args],
+		queryFn: () => fetchCountOfCollectables(args, config),
+	});
+};
+
+export const useCountOfCollectables = (args: UseCountOfCollectablesArgs) => {
+	const config = useConfig();
+	return useQuery(countOfCollectablesOptions(args, config));
+};

package/src/react/hooks/useConfig.tsx

@@ -0,0 +1,15 @@
+'use client';
+
+import { useContext } from 'react';
+
+import { MarketplaceSdkContext } from '../provider';
+
+export function useConfig() {
+	const context = useContext(MarketplaceSdkContext);
+	if (!context) {
+		throw new Error(
+			'Marketplace SDK must be used within a MarketplaceSdkProvider',
+		);
+	}
+	return context;
+}

package/src/react/hooks/useCurrencies.tsx

@@ -0,0 +1,76 @@
+import {
+	type ChainId,
+	type Currency,
+	type QueryArg,
+	configKeys,
+	currencyKeys,
+	getMarketplaceClient,
+	getQueryClient,
+} from '@internal';
+import { queryOptions, useQuery } from '@tanstack/react-query';
+import type { MarketplaceConfig, SdkConfig } from '@types';
+import { useConfig } from './useConfig';
+
+export type UseCurrenciesArgs = {
+	chainId: ChainId;
+	collectionAddress?: string;
+	includeNativeCurrency?: boolean;
+} & QueryArg;
+
+export type UseCurrenciesReturn = ReturnType<typeof fetchCurrencies>;
+
+const fetchCurrencies = async (chainId: ChainId, config: SdkConfig) => {
+	const marketplaceClient = getMarketplaceClient(chainId, config);
+	return marketplaceClient.listCurrencies().then((resp) => resp.currencies);
+};
+
+const selectCurrencies = (data: Currency[], args: UseCurrenciesArgs) => {
+	// if collectionAddress is passed, filter currencies based on collection currency options
+	if (args.collectionAddress) {
+		const queryClient = getQueryClient();
+		const marketplaceConfigCache = queryClient.getQueriesData({
+			queryKey: configKeys.marketplace,
+		})[0][1] as MarketplaceConfig;
+
+		const collection = marketplaceConfigCache?.collections.find(
+			(collection) => collection.collectionAddress === args.collectionAddress,
+		);
+
+		if (!collection) {
+			throw new Error("Collection doesn't exist");
+		}
+
+		return data.filter(
+			(currency) =>
+				collection.currencyOptions?.includes(currency.contractAddress) ||
+				// biome-ignore lint/suspicious/noDoubleEquals: <explanation>
+				currency.nativeCurrency == args.includeNativeCurrency ||
+				currency.defaultChainCurrency,
+		);
+	}
+	// if includeNativeCurrency is true, return all currencies
+	if (args.includeNativeCurrency) {
+		return data;
+	}
+
+	// if includeNativeCurrency is false or undefined, filter out native currencies
+	return data.filter((currency) => !currency.nativeCurrency);
+};
+
+export const currenciesOptions = (
+	args: UseCurrenciesArgs,
+	config: SdkConfig,
+) => {
+	return queryOptions({
+		...args.query,
+		queryKey: [...currencyKeys.lists, args.chainId],
+		queryFn: () => fetchCurrencies(args.chainId, config),
+		select: (data) => selectCurrencies(data, args),
+		enabled: args.query?.enabled,
+	});
+};
+
+export const useCurrencies = (args: UseCurrenciesArgs) => {
+	const config = useConfig();
+	return useQuery(currenciesOptions(args, config));
+};

package/src/react/hooks/useFilters.tsx

@@ -0,0 +1,39 @@
+import {
+	type ChainId,
+	type QueryArg,
+	collectableKeys,
+	getMetadataClient,
+} from '@internal';
+import { queryOptions, useQuery } from '@tanstack/react-query';
+import type { SdkConfig } from '@types';
+import { useConfig } from './useConfig';
+
+export type UseFiltersArgs = {
+	chainId: ChainId;
+	collectionAddress: string;
+} & QueryArg;
+
+export type UseFilterReturn = ReturnType<typeof fetchFilters>;
+
+export const fetchFilters = async (args: UseFiltersArgs, config: SdkConfig) => {
+	const metadataClient = getMetadataClient(config);
+	return metadataClient
+		.tokenCollectionFilters({
+			chainID: String(args.chainId),
+			contractAddress: args.collectionAddress,
+		})
+		.then((resp) => resp.filters);
+};
+
+export const filtersOptions = (args: UseFiltersArgs, config: SdkConfig) => {
+	return queryOptions({
+		...args.query,
+		queryKey: [...collectableKeys.filter, args, config],
+		queryFn: () => fetchFilters(args, config),
+	});
+};
+
+export const useFilters = (args: UseFiltersArgs) => {
+	const config = useConfig();
+	return useQuery(filtersOptions(args, config));
+};

package/src/react/hooks/useFloorOrder.tsx

@@ -0,0 +1,28 @@
+import { collectableKeys, getMarketplaceClient } from '@internal';
+import { queryOptions, useQuery } from '@tanstack/react-query';
+import type { SdkConfig } from '@types';
+import { useConfig } from './useConfig';
+
+export type UseFloorOrder = {
+	chainId: string;
+	collectionAddress: string;
+};
+
+const fetchFloorOrder = async (args: UseFloorOrder, config: SdkConfig) => {
+	const marketplaceClient = getMarketplaceClient(args.chainId, config);
+	return marketplaceClient
+		.getFloorOrder({ contractAddress: args.collectionAddress })
+		.then((data) => data.collectible);
+};
+
+export const floorOrderOptions = (args: UseFloorOrder, config: SdkConfig) => {
+	return queryOptions({
+		queryKey: [...collectableKeys.floorOrders, args, config],
+		queryFn: () => fetchFloorOrder(args, config),
+	});
+};
+
+export const useFloorOrder = (args: UseFloorOrder) => {
+	const config = useConfig();
+	return useQuery(floorOrderOptions(args, config));
+};

package/src/react/hooks/useGenerateListingTransaction.tsx

@@ -0,0 +1,63 @@
+import {
+	type ChainId,
+	type GenerateListingTransactionArgs,
+	getMarketplaceClient,
+} from '@internal';
+import { useMutation } from '@tanstack/react-query';
+import type { SdkConfig, Step } from '@types';
+import { useConfig } from './useConfig';
+
+export type UseGenerateListingTransactionArgs = {
+	chainId: ChainId;
+	onSuccess?: (data?: Step[]) => void;
+};
+
+import type { CreateReq } from '@types';
+
+export type CreateReqWithDateExpiry = Omit<CreateReq, 'expiry'> & {
+	expiry: Date;
+};
+
+export type GenerateListingTransactionProps = Omit<
+	GenerateListingTransactionArgs,
+	'listing'
+> & {
+	listing: CreateReqWithDateExpiry;
+};
+
+const dateToUnixTime = (date: Date) =>
+	Math.floor(date.getTime() / 1000).toString();
+
+export const generateListingTransaction = async (
+	params: GenerateListingTransactionProps,
+	config: SdkConfig,
+	chainId: ChainId,
+) => {
+	const args = {
+		...params,
+		listing: {
+			...params.listing,
+			expiry: dateToUnixTime(params.listing.expiry),
+		},
+	} satisfies GenerateListingTransactionArgs;
+	const marketplaceClient = getMarketplaceClient(chainId, config);
+	return (await marketplaceClient.generateListingTransaction(args)).steps;
+};
+
+export const useGenerateListingTransaction = (
+	params: UseGenerateListingTransactionArgs,
+) => {
+	const config = useConfig();
+
+	const { mutate, mutateAsync, ...result } = useMutation({
+		onSuccess: params.onSuccess,
+		mutationFn: (args: GenerateListingTransactionProps) =>
+			generateListingTransaction(args, config, params.chainId),
+	});
+
+	return {
+		...result,
+		generateListingTransaction: mutate,
+		generateListingTransactionAsync: mutateAsync,
+	};
+};

package/src/react/hooks/useGenerateOfferTransaction.tsx

@@ -0,0 +1,60 @@
+import {
+	type ChainId,
+	type GenerateOfferTransactionArgs,
+	getMarketplaceClient,
+} from '@internal';
+import { useMutation } from '@tanstack/react-query';
+import type { SdkConfig, Step } from '@types';
+import { useConfig } from './useConfig';
+
+export type UseGenerateOfferTransactionArgs = {
+	chainId: ChainId;
+	onSuccess?: (data?: Step[]) => void;
+};
+
+import type { CreateReq } from '@types';
+
+type CreateReqWithDateExpiry = Omit<CreateReq, 'expiry'> & {
+	expiry: Date;
+};
+
+export type GenerateOfferTransactionProps = Omit<
+	GenerateOfferTransactionArgs,
+	'offer'
+> & {
+	offer: CreateReqWithDateExpiry;
+};
+
+const dateToUnixTime = (date: Date) =>
+	Math.floor(date.getTime() / 1000).toString();
+
+export const generateOfferTransaction = async (
+	params: GenerateOfferTransactionProps,
+	config: SdkConfig,
+	chainId: ChainId,
+) => {
+	const args = {
+		...params,
+		offer: { ...params.offer, expiry: dateToUnixTime(params.offer.expiry) },
+	} satisfies GenerateOfferTransactionArgs;
+	const marketplaceClient = getMarketplaceClient(chainId, config);
+	return (await marketplaceClient.generateOfferTransaction(args)).steps;
+};
+
+export const useGenerateOfferTransaction = (
+	params: UseGenerateOfferTransactionArgs,
+) => {
+	const config = useConfig();
+
+	const { mutate, mutateAsync, ...result } = useMutation({
+		onSuccess: params.onSuccess,
+		mutationFn: (args: GenerateOfferTransactionProps) =>
+			generateOfferTransaction(args, config, params.chainId),
+	});
+
+	return {
+		...result,
+		generateOfferTransaction: mutate,
+		generateOfferTransactionAsync: mutateAsync,
+	};
+};

package/src/react/hooks/useGenerateSellTransaction.tsx

@@ -0,0 +1,43 @@
+import {
+	type ChainId,
+	type GenerateSellTransactionArgs,
+	getMarketplaceClient,
+} from '@internal';
+import { useMutation } from '@tanstack/react-query';
+import type { SdkConfig } from '@types';
+import { useConfig } from './useConfig';
+
+export type UseGenerateSellTransactionArgs = {
+	chainId: ChainId;
+	onSuccess?: () => void | Promise<void>;
+};
+
+export const generateSellTransaction = async (
+	args: GenerateSellTransactionArgs,
+	config: SdkConfig,
+	chainId: ChainId,
+) => {
+	console.log('generateSellTransaction');
+	console.log(args);
+	console.log(chainId);
+	const marketplaceClient = getMarketplaceClient(chainId, config);
+	return marketplaceClient.generateSellTransaction(args);
+};
+
+export const useGenerateSellTransaction = (
+	params: UseGenerateSellTransactionArgs,
+) => {
+	const config = useConfig();
+
+	const { mutate, mutateAsync, ...result } = useMutation({
+		onSuccess: params.onSuccess,
+		mutationFn: (args: GenerateSellTransactionArgs) =>
+			generateSellTransaction(args, config, params.chainId),
+	});
+
+	return {
+		...result,
+		generateSellTransaction: mutate,
+		generateSellTransactionAsync: mutateAsync,
+	};
+};

package/src/react/hooks/useHighestOffer.tsx

@@ -0,0 +1,46 @@
+import {
+	type GetCollectibleHighestOfferArgs,
+	type QueryArg,
+	collectableKeys,
+	getMarketplaceClient,
+} from '@internal';
+import { queryOptions, useQuery } from '@tanstack/react-query';
+import type { SdkConfig } from '@types';
+import { useConfig } from './useConfig';
+
+export type UseHighestOfferArgs = Omit<
+	GetCollectibleHighestOfferArgs,
+	'contractAddress'
+> & {
+	collectionAddress: string;
+	chainId: string;
+} & QueryArg;
+
+export type UseHighestOfferReturn = ReturnType<typeof fetchHighestOffer>;
+
+const fetchHighestOffer = async (
+	args: UseHighestOfferArgs,
+	config: SdkConfig,
+) => {
+	const marketplaceClient = getMarketplaceClient(args.chainId, config);
+	return marketplaceClient.getCollectibleHighestOffer({
+		...args,
+		contractAddress: args.collectionAddress,
+	});
+};
+
+export const highestOfferOptions = (
+	args: UseHighestOfferArgs,
+	config: SdkConfig,
+) => {
+	return queryOptions({
+		...args.query,
+		queryKey: [...collectableKeys.highestOffers, args, config],
+		queryFn: () => fetchHighestOffer(args, config),
+	});
+};
+
+export const useHighestOffer = (args: UseHighestOfferArgs) => {
+	const config = useConfig();
+	return useQuery(highestOfferOptions(args, config));
+};

package/src/react/hooks/useListBalances.tsx

@@ -0,0 +1,56 @@
+import type { MetadataOptions, Page } from '@0xsequence/indexer';
+import {
+	type ChainId,
+	type QueryArg,
+	balanceQueries,
+	getIndexerClient,
+} from '@internal';
+import { infiniteQueryOptions, useInfiniteQuery } from '@tanstack/react-query';
+import type { SdkConfig } from '@types';
+import { useConfig } from './useConfig';
+
+export type UseTokenBalancesArgs = {
+	chainId: ChainId;
+	accountAddress?: string;
+	contractAddress?: string;
+	tokenId?: string;
+	includeMetadata?: boolean;
+	metadataOptions?: MetadataOptions;
+	includeCollectionTokens?: boolean;
+	page?: Page;
+} & QueryArg;
+
+export type UseFetchTokenBalancesReturn = ReturnType<typeof fetchTokenBalances>;
+
+const fetchTokenBalances = async (
+	args: UseTokenBalancesArgs,
+	page: Page,
+	config: SdkConfig,
+) => {
+	const indexerClient = getIndexerClient(args.chainId, config);
+
+	return indexerClient.getTokenBalances({
+		...args,
+		tokenID: args.tokenId,
+		page: page,
+	});
+};
+
+export const tokenBalancesOptions = (
+	args: UseTokenBalancesArgs,
+	config: SdkConfig,
+) => {
+	return infiniteQueryOptions({
+		...args.query,
+		queryKey: [...balanceQueries.lists, args, config],
+		queryFn: ({ pageParam }: { pageParam: Page }) =>
+			fetchTokenBalances(args, pageParam, config),
+		initialPageParam: { page: 1, pageSize: 30 } as Page,
+		getNextPageParam: (lastPage) => lastPage.page.after,
+	});
+};
+
+export const useTokenBalances = (args: UseTokenBalancesArgs) => {
+	const config = useConfig();
+	return useInfiniteQuery(tokenBalancesOptions(args, config));
+};

package/src/react/hooks/useListCollectibles.tsx

@@ -0,0 +1,54 @@
+import {
+	type ChainId,
+	type ListCollectiblesArgs,
+	type Page,
+	collectableKeys,
+	getMarketplaceClient,
+} from '@internal';
+import { infiniteQueryOptions, useInfiniteQuery } from '@tanstack/react-query';
+import type { SdkConfig } from '@types';
+import { useConfig } from './useConfig';
+
+export type UseListCollectiblesArgs = Omit<
+	ListCollectiblesArgs,
+	'contractAddress'
+> & {
+	collectionAddress: string;
+	chainId: ChainId;
+};
+
+export type UseListCollectiblesReturn = ReturnType<typeof fetchCollectibles>;
+
+const fetchCollectibles = async (
+	args: UseListCollectiblesArgs,
+	page: Page,
+	marketplaceClient: ReturnType<typeof getMarketplaceClient>,
+) => {
+	const arg = {
+		...args,
+		contractAddress: args.collectionAddress,
+		page,
+	} satisfies ListCollectiblesArgs;
+
+	return marketplaceClient.listCollectibles(arg);
+};
+
+export const listCollectiblesOptions = (
+	args: UseListCollectiblesArgs,
+	config: SdkConfig,
+) => {
+	const marketplaceClient = getMarketplaceClient(args.chainId, config);
+	return infiniteQueryOptions({
+		queryKey: [...collectableKeys.lists, args, marketplaceClient],
+		queryFn: ({ pageParam }) =>
+			fetchCollectibles(args, pageParam, marketplaceClient),
+		initialPageParam: { page: 1, pageSize: 30 },
+		getNextPageParam: (lastPage) =>
+			lastPage.page?.more ? lastPage.page : undefined,
+	});
+};
+
+export const useListCollectibles = (args: UseListCollectiblesArgs) => {
+	const config = useConfig();
+	return useInfiniteQuery(listCollectiblesOptions(args, config));
+};

package/src/react/hooks/useListOffersForCollectible.tsx

@@ -0,0 +1,53 @@
+import {
+	type ListOffersForCollectibleArgs,
+	collectableKeys,
+	getMarketplaceClient,
+} from '@internal';
+import { infiniteQueryOptions, useInfiniteQuery } from '@tanstack/react-query';
+import type { Page, SdkConfig } from '@types';
+import { useConfig } from './useConfig';
+
+export type UseListOffersForCollectibleArgs = ListOffersForCollectibleArgs & {
+	chainId: string;
+};
+
+export type UseListOffersForCollectible = ReturnType<
+	typeof fetchListOffersForCollectible
+>;
+
+const fetchListOffersForCollectible = async (
+	config: SdkConfig,
+	args: UseListOffersForCollectibleArgs,
+	page: Page,
+) => {
+	const arg = {
+		contractAddress: args.contractAddress,
+		tokenId: args.tokenId,
+		filter: args.filter,
+		page,
+	} satisfies ListOffersForCollectibleArgs;
+
+	const marketplaceClient = getMarketplaceClient(args.chainId, config);
+	return marketplaceClient.listCollectibleOffers(arg);
+};
+
+export const listOffersForCollectibleOptions = (
+	args: UseListOffersForCollectibleArgs,
+	config: SdkConfig,
+) => {
+	return infiniteQueryOptions({
+		queryKey: [...collectableKeys.offers, args, config],
+		queryFn: ({ pageParam }) =>
+			fetchListOffersForCollectible(config, args, pageParam),
+		initialPageParam: { page: 1, pageSize: 30 },
+		getNextPageParam: (lastPage) =>
+			lastPage.page?.more ? lastPage.page : undefined,
+	});
+};
+
+export const useListOffersForCollectible = (
+	args: UseListOffersForCollectibleArgs,
+) => {
+	const config = useConfig();
+	return useInfiniteQuery(listOffersForCollectibleOptions(args, config));
+};

package/src/react/hooks/useLowestListing.tsx

@@ -0,0 +1,47 @@
+import {
+	type ChainId,
+	type GetCollectibleLowestListingArgs,
+	type QueryArg,
+	collectableKeys,
+	getMarketplaceClient,
+} from '@internal';
+import { queryOptions, useQuery } from '@tanstack/react-query';
+import type { SdkConfig } from '@types';
+import { useConfig } from './useConfig';
+
+export type UseLowestListingArgs = Omit<
+	GetCollectibleLowestListingArgs,
+	'contractAddress'
+> & {
+	collectionAddress: string;
+	chainId: ChainId;
+} & QueryArg;
+
+export type UseLowestListingReturn = ReturnType<typeof fetchLowestListing>;
+
+const fetchLowestListing = async (
+	args: UseLowestListingArgs,
+	config: SdkConfig,
+) => {
+	const marketplaceClient = getMarketplaceClient(args.chainId, config);
+	return marketplaceClient.getCollectibleLowestListing({
+		...args,
+		contractAddress: args.collectionAddress,
+	});
+};
+
+export const lowestListingOptions = (
+	args: UseLowestListingArgs,
+	config: SdkConfig,
+) => {
+	return queryOptions({
+		...args.query,
+		queryKey: [...collectableKeys.lowestListings, args, config],
+		queryFn: () => fetchLowestListing(args, config),
+	});
+};
+
+export const useLowestListing = (args: UseLowestListingArgs) => {
+	const config = useConfig();
+	return useQuery(lowestListingOptions(args, config));
+};

package/src/react/hooks/useMarketplaceConfig.tsx

@@ -0,0 +1,10 @@
+import { useQuery } from '@tanstack/react-query';
+import { marketplaceConfigOptions } from './options/marketplaceConfigOptions';
+import { useConfig } from './useConfig';
+
+export * from './options/marketplaceConfigOptions';
+
+export const useMarketplaceConfig = () => {
+	const config = useConfig();
+	return useQuery(marketplaceConfigOptions(config));
+};