@0xsequence/marketplace-sdk 0.10.0 → 1.1.0

package/src/react/_internal/wallet/wallet.ts

@@ -1,313 +0,0 @@
-import type { TransactionReceipt } from '@0xsequence/indexer';
-import {
-	type Account,
-	type Address,
-	BaseError,
-	type Chain,
-	custom,
-	erc20Abi,
-	erc721Abi,
-	type Hex,
-	hexToBigInt,
-	isHex,
-	type PublicClient,
-	TransactionReceiptNotFoundError,
-	type TypedDataDomain,
-	UserRejectedRequestError as ViemUserRejectedRequestError,
-	type WalletClient as ViemWalletClient,
-	WaitForTransactionReceiptTimeoutError,
-} from 'viem';
-import type { Connector } from 'wagmi';
-import type { SwitchChainErrorType } from 'wagmi/actions';
-import {
-	SEQUENCE_MARKET_V1_ADDRESS,
-	SEQUENCE_MARKET_V2_ADDRESS,
-} from '../../../consts';
-import type { SdkConfig } from '../../../types';
-import { ERC1155_ABI } from '../../../utils';
-import {
-	ChainSwitchError,
-	TransactionConfirmationError,
-	TransactionExecutionError,
-	TransactionSignatureError,
-	UserRejectedRequestError,
-} from '../../../utils/_internal/error/transaction';
-import { getIndexerClient, StepType, WalletKind } from '../api';
-import { createLogger } from '../logger';
-import type { SignatureStep, TransactionStep } from '../utils';
-
-interface WalletClient extends Omit<ViemWalletClient, 'account'> {
-	account: Account;
-}
-
-export interface WalletInstance {
-	transport: ReturnType<typeof custom>;
-	isWaaS: boolean;
-	walletKind: WalletKind;
-	getChainId: () => Promise<number>;
-	switchChain: (chainId: number) => Promise<void>;
-	address: () => Promise<Address>;
-	handleSignMessageStep: (stepItem: SignatureStep) => Promise<Hex | undefined>;
-	handleSendTransactionStep: (
-		chainId: number,
-		stepItem: TransactionStep,
-	) => Promise<Hex>;
-	handleConfirmTransactionStep: (
-		txHash: Hex,
-		chainId: number,
-	) => Promise<TransactionReceipt>;
-	hasTokenApproval: (args: {
-		tokenType: 'ERC20' | 'ERC721' | 'ERC1155';
-		contractAddress: Address;
-		spender: Address | 'sequenceMarketV1' | 'sequenceMarketV2';
-	}) => Promise<bigint | boolean>;
-	publicClient: PublicClient;
-}
-
-const isSequenceWallet = (connector: Connector) =>
-	connector.id === 'sequence' || connector.id === 'sequence-waas';
-
-export const wallet = ({
-	wallet,
-	chains,
-	connector,
-	sdkConfig,
-	publicClient,
-}: {
-	wallet: WalletClient;
-	chains: readonly [Chain, ...Chain[]];
-	connector: Connector;
-	sdkConfig: SdkConfig;
-	publicClient: PublicClient;
-}): WalletInstance => {
-	const logger = createLogger('Wallet');
-
-	const walletInstance = {
-		transport: custom(wallet.transport),
-		isWaaS: connector.id.endsWith('waas'),
-		walletKind: isSequenceWallet(connector)
-			? WalletKind.sequence
-			: WalletKind.unknown,
-		getChainId: wallet.getChainId,
-		address: async () => {
-			let address = wallet.account?.address;
-			if (!address) {
-				[address] = await wallet.getAddresses();
-			}
-			return address;
-		},
-		switchChain: async (chainId: number) => {
-			logger.debug('Switching chain', { targetChainId: chainId });
-
-			try {
-				await wallet.switchChain({
-					id: chainId,
-				});
-				logger.info('Chain switch successful', { chainId });
-				return;
-			} catch (e) {
-				const error = e as SwitchChainErrorType;
-				logger.error('Chain switch failed', error);
-
-				switch (error.name) {
-					case 'SwitchChainNotSupportedError':
-						throw new ChainSwitchError(await wallet.getChainId(), chainId);
-					case 'UserRejectedRequestError':
-						throw new UserRejectedRequestError();
-					case 'ChainNotConfiguredError':
-						return;
-					default:
-						throw new ChainSwitchError(await wallet.getChainId(), chainId);
-				}
-			}
-		},
-		handleSignMessageStep: async (stepItem: SignatureStep) => {
-			try {
-				if (stepItem.id === StepType.signEIP191) {
-					logger.debug('Signing with EIP-191', { data: stepItem.data });
-					const message = isHex(stepItem.data)
-						? { raw: stepItem.data }
-						: stepItem.data;
-					return await wallet.signMessage({
-						account: wallet.account,
-						message,
-					});
-				}
-				if (stepItem.id === StepType.signEIP712) {
-					logger.debug('Signing with EIP-712', {
-						domain: stepItem.domain,
-						types: stepItem.signature?.types,
-					});
-					return await wallet.signTypedData({
-						account: wallet.account,
-						// biome-ignore lint/style/noNonNullAssertion: signature is guaranteed to exist for EIP712 step type
-						domain: stepItem.signature!.domain as TypedDataDomain,
-						// biome-ignore lint/style/noNonNullAssertion: signature is guaranteed to exist for EIP712 step type
-						types: stepItem.signature!.types,
-						// biome-ignore lint/style/noNonNullAssertion: signature is guaranteed to exist for EIP712 step type
-						primaryType: stepItem.signature!.primaryType,
-						// biome-ignore lint/style/noNonNullAssertion: signature is guaranteed to exist for EIP712 step type
-						message: stepItem.signature!.value,
-					});
-				}
-			} catch (e) {
-				const error = e as TransactionSignatureError;
-				logger.error('Signature failed', error);
-
-				if (error.cause instanceof BaseError) {
-					const viemError = error.cause as BaseError;
-					if (viemError instanceof ViemUserRejectedRequestError) {
-						throw new UserRejectedRequestError();
-					}
-				}
-
-				throw new TransactionSignatureError(stepItem.id, error as Error);
-			}
-		},
-		handleSendTransactionStep: async (
-			chainId: number,
-			stepItem: TransactionStep,
-		) => {
-			logger.debug('Sending transaction', {
-				chainId,
-				to: stepItem.to,
-				value: stepItem.value,
-			});
-
-			const chain = chains.find((chain) => chain.id === chainId);
-			try {
-				return await wallet.sendTransaction({
-					chain,
-					data: stepItem.data,
-					account: wallet.account,
-					to: stepItem.to,
-					value: hexToBigInt(stepItem.value || '0x0'),
-					...(stepItem.maxFeePerGas && {
-						maxFeePerGas: hexToBigInt(stepItem.maxFeePerGas),
-					}),
-					...(stepItem.maxPriorityFeePerGas && {
-						maxPriorityFeePerGas: hexToBigInt(stepItem.maxPriorityFeePerGas),
-					}),
-					...(stepItem.gas && {
-						gas: hexToBigInt(stepItem.gas),
-					}),
-				});
-			} catch (e) {
-				const error = e as TransactionExecutionError;
-				logger.error('Transaction failed', error);
-
-				if (error.cause instanceof BaseError) {
-					const viemError = error.cause as BaseError;
-					if (viemError instanceof ViemUserRejectedRequestError) {
-						throw new UserRejectedRequestError();
-					}
-				}
-
-				throw new TransactionExecutionError(stepItem.id, error as Error);
-			}
-		},
-		handleConfirmTransactionStep: async (txHash: Hex, chainId: number) => {
-			logger.debug('Confirming transaction', { txHash, chainId });
-			try {
-				const receipt = await awaitTransactionReceipt({
-					txHash,
-					chainId,
-					sdkConfig,
-				});
-				logger.info('Transaction confirmed', { txHash, receipt });
-				return receipt;
-			} catch (error) {
-				logger.error('Transaction confirmation failed', error);
-
-				throw new TransactionConfirmationError(txHash, error as Error);
-			}
-		},
-		hasTokenApproval: async ({
-			tokenType,
-			contractAddress,
-			spender,
-		}: {
-			tokenType: 'ERC20' | 'ERC721' | 'ERC1155';
-			contractAddress: Address;
-			spender: Address | 'sequenceMarketV1' | 'sequenceMarketV2';
-		}) => {
-			const walletAddress = await walletInstance.address();
-			const spenderAddress =
-				spender === 'sequenceMarketV1'
-					? SEQUENCE_MARKET_V1_ADDRESS
-					: spender === 'sequenceMarketV2'
-						? SEQUENCE_MARKET_V2_ADDRESS
-						: spender;
-
-			switch (tokenType) {
-				case 'ERC20':
-					return (await publicClient.readContract({
-						address: contractAddress as Address,
-						abi: erc20Abi,
-						functionName: 'allowance',
-						args: [walletAddress, spenderAddress],
-					})) as bigint;
-				case 'ERC721':
-					return (await publicClient.readContract({
-						address: contractAddress as Address,
-						abi: erc721Abi,
-						functionName: 'isApprovedForAll',
-						args: [walletAddress, spenderAddress],
-					})) as boolean;
-				case 'ERC1155':
-					return (await publicClient.readContract({
-						address: contractAddress as Address,
-						abi: ERC1155_ABI,
-						functionName: 'isApprovedForAll',
-						args: [walletAddress, spenderAddress],
-					})) as boolean;
-				default:
-					throw new Error('Unsupported contract type for approval checking');
-			}
-		},
-		publicClient,
-	};
-
-	return walletInstance;
-};
-
-const ONE_MIN = 60 * 1000;
-const THREE_MIN = 3 * ONE_MIN;
-
-const awaitTransactionReceipt = async ({
-	txHash,
-	chainId,
-	sdkConfig,
-	timeout = THREE_MIN,
-}: {
-	txHash: Hex;
-	chainId: number;
-	sdkConfig: SdkConfig;
-	timeout?: number;
-}) => {
-	const indexer = getIndexerClient(chainId, sdkConfig);
-	return Promise.race([
-		new Promise<TransactionReceipt>((resolve, reject) => {
-			indexer.subscribeReceipts(
-				{
-					filter: {
-						txnHash: txHash,
-					},
-				},
-				{
-					onMessage: ({ receipt }) => {
-						resolve(receipt);
-					},
-					onError: () => {
-						reject(TransactionReceiptNotFoundError);
-					},
-				},
-			);
-		}),
-		new Promise<TransactionReceipt>((_, reject) => {
-			setTimeout(() => {
-				reject(WaitForTransactionReceiptTimeoutError);
-			}, timeout);
-		}),
-	]);
-};

package/src/react/hooks/options/index.ts

@@ -1 +0,0 @@
-export * from '../../queries/marketplaceConfig';

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/useERC721SaleMintedTokens.tsx

@@ -1,70 +0,0 @@
-import type { Address } from 'viem';
-import { useReadContract } from 'wagmi';
-import { ERC721_SALE_ABI } from '../../../../sdk/src';
-import { useTokenSupplies } from './useTokenSupplies';
-
-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 } =
-		useTokenSupplies({
-			chainId,
-			collectionAddress: contractAddress as Address,
-		});
-
-	const isLoading = saleDetailsLoading || tokenSuppliesLoading;
-
-	// Count how many tokens have been minted/owned
-	const ownedCount = tokenIds.reduce((count, tokenId) => {
-		let supply: { tokenID: string; supply: string } | undefined;
-
-		if (tokenSupplies) {
-			supply = tokenSupplies.tokenIDs.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,
-	};
-}

package/src/react/hooks/useInventory.tsx

@@ -1,18 +0,0 @@
-import { useInfiniteQuery } from '@tanstack/react-query';
-import { ContractType } from '../_internal';
-import { inventoryOptions, type UseInventoryArgs } from '../queries/inventory';
-import { useConfig } from './useConfig';
-import { useMarketplaceConfig } from './useMarketplaceConfig';
-
-export function useInventory(args: UseInventoryArgs) {
-	const config = useConfig();
-	const { data: marketplaceConfig } = useMarketplaceConfig();
-
-	const isLaos721 =
-		marketplaceConfig?.market?.collections?.find(
-			(c) =>
-				c.itemsAddress === args.collectionAddress && c.chainId === args.chainId,
-		)?.contractType === ContractType.LAOS_ERC_721;
-
-	return useInfiniteQuery(inventoryOptions({ ...args, isLaos721 }, config));
-}

package/src/react/hooks/useList1155SaleSupplies.tsx

@@ -1,62 +0,0 @@
-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,
-	};
-}