@0xsequence/marketplace-sdk 0.9.0 → 1.0.0

package/src/react/hooks/useCancelTransactionSteps.tsx

@@ -1,249 +0,0 @@
-import type { Hex } from 'viem';
-import {
-	ChainSwitchUserRejectedError,
-	WalletInstanceNotFoundError,
-} from '../../utils/_internal/error/transaction';
-import {
-	ExecuteType,
-	getMarketplaceClient,
-	getQueryClient,
-	type MarketplaceKind,
-	type Step,
-	StepType,
-} from '../_internal';
-import type {
-	SignatureStep,
-	TransactionStep as walletTransactionStep,
-} from '../_internal/utils';
-import { useWallet } from '../_internal/wallet/useWallet';
-import { useSwitchChainModal } from '../ui/modals/_internal/components/switchChainModal';
-import type { ModalCallbacks } from '../ui/modals/_internal/types';
-import type { TransactionStep } from './useCancelOrder';
-import { useConfig } from './useConfig';
-import { useGenerateCancelTransaction } from './useGenerateCancelTransaction';
-import {
-	invalidateQueriesOnCancel,
-	updateQueriesOnCancel,
-} from './util/optimisticCancelUpdates';
-
-interface UseCancelTransactionStepsArgs {
-	collectionAddress: string;
-	chainId: number;
-	callbacks?: ModalCallbacks;
-	setSteps: React.Dispatch<React.SetStateAction<TransactionStep>>;
-	onSuccess?: ({ hash, orderId }: { hash?: string; orderId?: string }) => void;
-	onError?: (error: Error) => void;
-}
-
-export const useCancelTransactionSteps = ({
-	collectionAddress,
-	chainId,
-	callbacks,
-	setSteps,
-	onSuccess,
-	onError,
-}: UseCancelTransactionStepsArgs) => {
-	const { show: showSwitchChainModal } = useSwitchChainModal();
-	const { wallet, isLoading, isError } = useWallet();
-	const walletIsInitialized = wallet && !isLoading && !isError;
-	const sdkConfig = useConfig();
-	const marketplaceClient = getMarketplaceClient(sdkConfig);
-	const { generateCancelTransactionAsync } = useGenerateCancelTransaction({
-		chainId,
-	});
-
-	const getWalletChainId = async () => {
-		return await wallet?.getChainId();
-	};
-	const switchChain = async () => {
-		await wallet?.switchChain(Number(chainId));
-	};
-	const checkAndSwitchChain = async () => {
-		const walletChainId = await getWalletChainId();
-		const isWaaS = wallet?.isWaaS;
-		const chainIdMismatch = walletChainId !== Number(chainId);
-
-		return new Promise((resolve, reject) => {
-			if (chainIdMismatch) {
-				if (isWaaS) {
-					switchChain().then(resolve).catch(reject);
-				} else {
-					showSwitchChainModal({
-						chainIdToSwitchTo: chainId,
-						onSuccess: () => resolve({ chainId: chainId }),
-						onError: (error) => reject(error),
-						onClose: () => reject(new ChainSwitchUserRejectedError()),
-					});
-				}
-			} else {
-				resolve({ chainId: chainId });
-			}
-		});
-	};
-
-	const getCancelSteps = async ({
-		orderId,
-		marketplace,
-	}: {
-		orderId: string;
-		marketplace: MarketplaceKind;
-	}) => {
-		try {
-			const address = await wallet?.address();
-
-			if (!address) {
-				throw new Error('Wallet address not found');
-			}
-
-			const steps = await generateCancelTransactionAsync({
-				chainId,
-				collectionAddress,
-				maker: address,
-				marketplace,
-				orderId,
-			});
-
-			return steps;
-		} catch (error) {
-			if (callbacks?.onError) {
-				callbacks.onError(error as Error);
-			} else {
-				console.debug('onError callback not provided:', error);
-			}
-		}
-	};
-
-	const cancelOrder = async ({
-		orderId,
-		marketplace,
-	}: {
-		orderId: string;
-		marketplace: MarketplaceKind;
-	}) => {
-		const queryClient = getQueryClient();
-		if (!walletIsInitialized) {
-			throw new WalletInstanceNotFoundError();
-		}
-
-		try {
-			await checkAndSwitchChain();
-
-			setSteps((prev) => ({
-				...prev,
-				isExecuting: true,
-			}));
-
-			const cancelSteps = await getCancelSteps({
-				orderId,
-				marketplace,
-			});
-			const transactionStep = cancelSteps?.find(
-				(step) => step.id === StepType.cancel,
-			);
-			const signatureStep = cancelSteps?.find(
-				(step) => step.id === StepType.signEIP712,
-			);
-
-			console.debug('transactionStep', transactionStep);
-			console.debug('signatureStep', signatureStep);
-
-			if (!transactionStep && !signatureStep) {
-				throw new Error('No transaction or signature step found');
-			}
-
-			let hash: Hex | undefined;
-			let reservoirOrderId: string | undefined;
-
-			if (transactionStep && wallet) {
-				hash = await executeTransaction({ transactionStep });
-
-				if (hash) {
-					await wallet.handleConfirmTransactionStep(hash, Number(chainId));
-
-					if (onSuccess && typeof onSuccess === 'function') {
-						onSuccess({ hash });
-
-						updateQueriesOnCancel({
-							orderId,
-							queryClient,
-						});
-					}
-
-					setSteps((prev) => ({
-						...prev,
-						isExecuting: false,
-					}));
-				}
-			}
-
-			if (signatureStep) {
-				reservoirOrderId = await executeSignature({ signatureStep });
-
-				if (onSuccess && typeof onSuccess === 'function') {
-					onSuccess({ orderId: reservoirOrderId });
-
-					updateQueriesOnCancel({
-						orderId: reservoirOrderId,
-						queryClient,
-					});
-				}
-
-				setSteps((prev) => ({
-					...prev,
-					isExecuting: false,
-				}));
-			}
-		} catch (error) {
-			invalidateQueriesOnCancel({
-				queryClient,
-			});
-
-			setSteps((prev) => ({
-				...prev,
-				isExecuting: false,
-			}));
-
-			if (onError && typeof onError === 'function') {
-				onError(error as Error);
-			}
-		}
-	};
-
-	const executeTransaction = async ({
-		transactionStep,
-	}: {
-		transactionStep: Step;
-	}): Promise<Hex | undefined> => {
-		const hash = await wallet?.handleSendTransactionStep(
-			Number(chainId),
-			transactionStep as walletTransactionStep,
-		);
-
-		return hash;
-	};
-
-	const executeSignature = async ({
-		signatureStep,
-	}: {
-		signatureStep: Step;
-	}) => {
-		const signature = await wallet?.handleSignMessageStep(
-			signatureStep as SignatureStep,
-		);
-
-		const result = await marketplaceClient.execute({
-			chainId: String(chainId),
-			signature: signature as string,
-			method: signatureStep.post?.method as string,
-			endpoint: signatureStep.post?.endpoint as string,
-			body: signatureStep.post?.body,
-			executeType: ExecuteType.order,
-		});
-
-		return result.orderId;
-	};
-
-	return {
-		cancelOrder,
-	};
-};

package/src/react/hooks/useCheckoutOptionsSalesContract.tsx

@@ -1,67 +0,0 @@
-import { queryOptions, skipToken, useQuery } from '@tanstack/react-query';
-import type { Hex } from 'viem';
-import { useAccount } from 'wagmi';
-import type { SdkConfig } from '../../types';
-import {
-	type CheckoutOptionsSalesContractArgs,
-	getMarketplaceClient,
-} from '../_internal';
-import { useConfig } from './useConfig';
-
-type UseCheckoutOptionsSalesContractArgs = Omit<
-	CheckoutOptionsSalesContractArgs,
-	'wallet' | 'chainId'
-> & { chainId: number };
-
-const fetchCheckoutOptionsSalesContract = async (
-	args: CheckoutOptionsSalesContractArgs,
-	config: SdkConfig,
-) => {
-	const marketplaceClient = getMarketplaceClient(config);
-	return marketplaceClient.checkoutOptionsSalesContract({
-		chainId: args.chainId,
-		wallet: args.wallet,
-		contractAddress: args.contractAddress,
-		collectionAddress: args.collectionAddress,
-		items: args.items,
-	});
-};
-
-export const checkoutOptionsSalesContractOptions = (
-	args:
-		| (UseCheckoutOptionsSalesContractArgs & { wallet?: Hex })
-		| typeof skipToken,
-	config: SdkConfig,
-) => {
-	return queryOptions({
-		queryKey: ['checkoutOptionsSalesContract', args],
-		queryFn:
-			skipToken === args
-				? skipToken
-				: () =>
-						fetchCheckoutOptionsSalesContract(
-							{
-								chainId: String(args.chainId),
-								// biome-ignore lint/style/noNonNullAssertion: wallet is guaranteed to exist when not skipToken
-								wallet: args.wallet!,
-								contractAddress: args.contractAddress,
-								collectionAddress: args.collectionAddress,
-								items: args.items,
-							},
-							config,
-						),
-	});
-};
-
-export const useCheckoutOptionsSalesContract = (
-	args: UseCheckoutOptionsSalesContractArgs | typeof skipToken,
-) => {
-	const { address } = useAccount();
-	const config = useConfig();
-	return useQuery(
-		checkoutOptionsSalesContractOptions(
-			skipToken === args ? skipToken : { ...args, wallet: address },
-			config,
-		),
-	);
-};

package/src/react/hooks/useCollectionBalanceDetails.tsx

@@ -1,79 +0,0 @@
-import type { GetTokenBalancesDetailsReturn } from '@0xsequence/indexer';
-import { queryOptions, useQuery } from '@tanstack/react-query';
-import type { Address } from 'viem';
-import type { SdkConfig } from '../../types';
-import type { QueryArg } from '../_internal';
-import { balanceQueries, getIndexerClient } from '../_internal';
-import { useConfig } from './useConfig';
-
-export interface CollectionBalanceFilter {
-	accountAddresses: Address[];
-	contractWhitelist?: Address[];
-	omitNativeBalances: boolean;
-}
-
-export interface UseCollectionBalanceDetailsArgs {
-	chainId: number;
-	filter: CollectionBalanceFilter;
-	query?: QueryArg;
-}
-
-const fetchCollectionBalanceDetails = async (
-	args: UseCollectionBalanceDetailsArgs,
-	indexerClient: Awaited<ReturnType<typeof getIndexerClient>>,
-) => {
-	const promises = args.filter.accountAddresses.map((accountAddress) =>
-		indexerClient.getTokenBalancesDetails({
-			filter: {
-				accountAddresses: [accountAddress],
-				contractWhitelist: args.filter.contractWhitelist,
-				omitNativeBalances: args.filter.omitNativeBalances,
-			},
-		}),
-	);
-
-	const responses = await Promise.all(promises);
-	const mergedResponse = responses.reduce<GetTokenBalancesDetailsReturn>(
-		(
-			acc: GetTokenBalancesDetailsReturn,
-			curr: GetTokenBalancesDetailsReturn | null,
-		) => {
-			if (!curr) return acc;
-			return {
-				page: curr.page,
-				nativeBalances: [
-					...(acc.nativeBalances || []),
-					...(curr.nativeBalances || []),
-				],
-				balances: [...(acc.balances || []), ...(curr.balances || [])],
-			};
-		},
-		{ page: {}, nativeBalances: [], balances: [] },
-	);
-
-	if (!mergedResponse) {
-		throw new Error('Failed to fetch collection balance details');
-	}
-
-	return mergedResponse;
-};
-
-export const collectionBalanceDetailsOptions = (
-	args: UseCollectionBalanceDetailsArgs,
-	config: SdkConfig,
-) => {
-	const indexerClient = getIndexerClient(args.chainId, config);
-
-	return queryOptions({
-		queryKey: [...balanceQueries.collectionBalanceDetails, args, config],
-		queryFn: () => fetchCollectionBalanceDetails(args, indexerClient),
-		...(args.query || {}),
-	});
-};
-
-export const useCollectionBalanceDetails = (
-	args: UseCollectionBalanceDetailsArgs,
-) => {
-	const config = useConfig();
-	return useQuery(collectionBalanceDetailsOptions(args, config));
-};

package/src/react/hooks/useComparePrices.tsx

@@ -1,96 +0,0 @@
-import { queryOptions, useQuery } from '@tanstack/react-query';
-import type { Address } from 'viem';
-import type { SdkConfig } from '../../types';
-import { currencyKeys, type QueryArg } from '../_internal';
-import { useConfig } from './useConfig';
-import { convertPriceToUSD } from './useConvertPriceToUSD';
-
-export interface UseComparePricesArgs {
-	chainId: number;
-	// First price details
-	priceAmountRaw: string;
-	priceCurrencyAddress: Address;
-	// Second price details (to compare against)
-	compareToPriceAmountRaw: string;
-	compareToPriceCurrencyAddress: Address;
-	query: QueryArg;
-}
-
-export interface UseComparePricesReturn {
-	percentageDifference: number;
-	percentageDifferenceFormatted: string;
-	status: 'above' | 'same' | 'below';
-}
-
-const comparePrices = async (
-	args: UseComparePricesArgs,
-	config: SdkConfig,
-): Promise<UseComparePricesReturn> => {
-	const [priceUSD, compareToPriceUSD] = await Promise.all([
-		convertPriceToUSD(
-			{
-				chainId: args.chainId,
-				currencyAddress: args.priceCurrencyAddress,
-				amountRaw: args.priceAmountRaw,
-				query: {},
-			},
-			config,
-		),
-		convertPriceToUSD(
-			{
-				chainId: args.chainId,
-				currencyAddress: args.compareToPriceCurrencyAddress,
-				amountRaw: args.compareToPriceAmountRaw,
-				query: {},
-			},
-			config,
-		),
-	]);
-	const difference = priceUSD.usdAmount - compareToPriceUSD.usdAmount;
-
-	if (compareToPriceUSD.usdAmount === 0) {
-		throw new Error('Cannot compare to zero price');
-	}
-
-	const percentageDifference = (difference / compareToPriceUSD.usdAmount) * 100;
-	const isAbove = percentageDifference > 0;
-	const isSame = percentageDifference === 0;
-
-	return {
-		percentageDifference,
-		percentageDifferenceFormatted: Math.abs(percentageDifference).toFixed(2),
-		status: isAbove ? 'above' : isSame ? 'same' : 'below',
-	};
-};
-
-export const comparePricesOptions = (
-	args: UseComparePricesArgs,
-	config: SdkConfig,
-) => {
-	return queryOptions({
-		...args.query,
-		queryKey: [...currencyKeys.conversion, 'compare', args],
-		queryFn: () => comparePrices(args, config),
-	});
-};
-
-/**
- * Hook to compare prices between different currencies by converting both to USD
- * @param args - The arguments for the hook
- * @returns The percentage difference between the two prices
- * @example
- * ```ts
- * const { data } = useComparePrices({
- *   chainId: 1,
- *   priceAmountRaw: "1000000000000000000",
- *   priceCurrencyAddress: "0x0000000000000000000000000000000000000000",
- * });
- *
- * console.log(data);
- * // { percentageDifference: 10, percentageDifferenceFormatted: "10.00", isAbove: true, isSame: false, isBelow: false }
- * ```
- */
-export const useComparePrices = (args: UseComparePricesArgs) => {
-	const config = useConfig();
-	return useQuery(comparePricesOptions(args, config));
-};

package/src/react/hooks/useConvertPriceToUSD.tsx

@@ -1,82 +0,0 @@
-import { queryOptions, useQuery } from '@tanstack/react-query';
-import { type Address, formatUnits } from 'viem';
-import type { SdkConfig } from '../../types';
-import { type Currency, currencyKeys, getQueryClient } from '../_internal';
-import { marketCurrenciesQueryOptions } from '../queries/marketCurrencies';
-import { useConfig } from './useConfig';
-
-export interface UseConvertPriceToUSDArgs {
-	chainId: number;
-	currencyAddress: Address;
-	amountRaw: string;
-	query?: {
-		enabled?: boolean;
-	};
-}
-
-export type UseConvertPriceToUSDReturn = {
-	usdAmount: number;
-	usdAmountFormatted: string;
-};
-
-export const convertPriceToUSD = async (
-	args: UseConvertPriceToUSDArgs,
-	config: SdkConfig,
-): Promise<UseConvertPriceToUSDReturn> => {
-	const queryClient = getQueryClient();
-	const currencies = (await queryClient.fetchQuery(
-		marketCurrenciesQueryOptions({
-			chainId: args.chainId,
-			config,
-		}),
-	)) as Currency[];
-	const currencyDetails = currencies.find(
-		(c: Currency) =>
-			c.contractAddress.toLowerCase() === args.currencyAddress.toLowerCase(),
-	);
-
-	if (!currencyDetails) {
-		throw new Error('Currency not found');
-	}
-
-	const amountDecimal = Number(
-		formatUnits(BigInt(args.amountRaw), currencyDetails.decimals),
-	);
-	const usdAmount = amountDecimal * currencyDetails.exchangeRate;
-
-	return {
-		usdAmount,
-		usdAmountFormatted: usdAmount.toFixed(2),
-	};
-};
-
-export const convertPriceToUSDOptions = (
-	args: UseConvertPriceToUSDArgs,
-	config: SdkConfig,
-) => {
-	return queryOptions({
-		...args.query,
-		queryKey: [...currencyKeys.conversion, args],
-		queryFn: () => convertPriceToUSD(args, config),
-	});
-};
-
-/**
- * Hook to convert a price amount from a specific currency to USD
- * @returns The price amount in USD and formatted USD amount
- * @example
- * ```ts
- * const { data } = useConvertPriceToUSD({
- *   chainId: 1,
- *   currencyAddress: "0x0000000000000000000000000000000000000000",
- *   amountRaw: "1000000000000000000",
- * });
- *
- * console.log(data);
- * // { usdAmount: 1000, usdAmountFormatted: "1000.00" }
- * ```
- */
-export const useConvertPriceToUSD = (args: UseConvertPriceToUSDArgs) => {
-	const config = useConfig();
-	return useQuery(convertPriceToUSDOptions(args, config));
-};

package/src/react/hooks/useCurrencyBalance.tsx

@@ -1,51 +0,0 @@
-import { skipToken, useQuery } from '@tanstack/react-query';
-import { type Address, erc20Abi, formatUnits, zeroAddress } from 'viem';
-import { usePublicClient } from 'wagmi';
-export function useCurrencyBalance({
-	currencyAddress,
-	chainId,
-	userAddress,
-}: {
-	currencyAddress: Address | undefined;
-	chainId: number | undefined;
-	userAddress: Address | undefined;
-}) {
-	const publicClient = usePublicClient({ chainId });
-
-	return useQuery({
-		queryKey: ['balance', currencyAddress, chainId, userAddress],
-		queryFn:
-			!!userAddress && !!chainId && !!currencyAddress && !!publicClient
-				? async () => {
-						if (currencyAddress === zeroAddress) {
-							const balance = await publicClient.getBalance({
-								address: userAddress,
-							});
-							return {
-								value: balance,
-								formatted: formatUnits(balance, 18),
-							};
-						}
-
-						const [balance, decimals] = await Promise.all([
-							publicClient.readContract({
-								address: currencyAddress,
-								abi: erc20Abi,
-								functionName: 'balanceOf',
-								args: [userAddress],
-							}),
-							publicClient.readContract({
-								address: currencyAddress,
-								abi: erc20Abi,
-								functionName: 'decimals',
-							}),
-						]);
-
-						return {
-							value: balance,
-							formatted: formatUnits(balance, decimals),
-						};
-					}
-				: skipToken,
-	});
-}

package/src/react/hooks/useERC721SaleMintedTokens.tsx

@@ -1,67 +0,0 @@
-import type { Address } from 'viem';
-import { useReadContract } from 'wagmi';
-import { ERC721_SALE_ABI } from '../../../../sdk/src';
-import { useGetTokenSuppliesMap } from './useGetTokenSuppliesMap';
-
-interface UseERC721SaleMintedTokensProps {
-	chainId: number;
-	contractAddress: Address;
-	salesContractAddress: Address;
-	enabled?: boolean;
-	tokenIds: string[];
-}
-
-export function useERC721SaleMintedTokens({
-	chainId,
-	contractAddress,
-	salesContractAddress,
-	tokenIds,
-	enabled = true,
-}: UseERC721SaleMintedTokensProps) {
-	const {
-		data: saleDetails,
-		isLoading: saleDetailsLoading,
-		error: saleDetailsError,
-	} = useReadContract({
-		chainId,
-		address: salesContractAddress,
-		abi: ERC721_SALE_ABI,
-		functionName: 'saleDetails',
-		query: {
-			enabled,
-		},
-	});
-
-	// Get token supplies for all potential tokens in the sale
-	const { data: tokenSupplies, isLoading: tokenSuppliesLoading } =
-		useGetTokenSuppliesMap({
-			chainId,
-			tokenIds,
-			collectionAddress: contractAddress as Address,
-		});
-
-	const isLoading = saleDetailsLoading || tokenSuppliesLoading;
-
-	// Count how many tokens have been minted/owned
-	const ownedCount = tokenIds.reduce((count, tokenId) => {
-		const supplies = tokenSupplies?.supplies[contractAddress];
-		const supply = supplies?.find((s) => s.tokenID === tokenId);
-		// If supply exists and is greater than 0, token exists and is owned
-		const hasOwner = supply ? BigInt(supply.supply) > 0n : false;
-		return count + (hasOwner ? 1 : 0);
-	}, 0);
-
-	const totalSupplyCap = saleDetails?.supplyCap
-		? Number(saleDetails.supplyCap)
-		: 0;
-	const remainingCount = Math.max(0, totalSupplyCap - ownedCount);
-
-	return {
-		ownedCount,
-		totalSupplyCap,
-		remainingCount,
-		isLoading,
-		error: saleDetailsError,
-		saleDetails,
-	};
-}