@0xsequence/marketplace-sdk 0.8.12 → 0.10.0

package/src/react/hooks/__tests__/useTransferTokens.test.tsx

@@ -0,0 +1,469 @@
+import { renderHook } from '@test';
+import type { Address } from 'viem';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { useAccount, useWriteContract } from 'wagmi';
+import { NoWalletConnectedError } from '../../../utils/_internal/error/transaction';
+import { ContractType } from '../../_internal';
+import {
+	type TransferTokensParams,
+	useTransferTokens,
+} from '../useTransferTokens';
+
+// Mock wagmi hooks
+vi.mock('wagmi', async () => {
+	const actual = await vi.importActual('wagmi');
+	return {
+		...actual,
+		useAccount: vi.fn(),
+		useWriteContract: vi.fn(),
+	};
+});
+
+const mockUseAccount = vi.mocked(useAccount);
+const mockUseWriteContract = vi.mocked(useWriteContract);
+
+describe('useTransferTokens', () => {
+	const mockAccountAddress = '0x742d35Cc6634C0532925a3b8D4C9db96' as Address;
+	const mockReceiverAddress =
+		'0x456789abcdef123456789abcdef123456789abcdef' as Address;
+	const mockCollectionAddress =
+		'0x123456789abcdef123456789abcdef123456789abc' as Address;
+	const mockWriteContractAsync = vi.fn();
+
+	beforeEach(() => {
+		vi.clearAllMocks();
+
+		mockUseAccount.mockReturnValue({
+			address: mockAccountAddress,
+			chainId: 1,
+			addresses: [mockAccountAddress],
+			chain: undefined,
+			connector: undefined,
+			isConnected: true,
+			isConnecting: false,
+			isDisconnected: false,
+			isReconnecting: false,
+			status: 'connected',
+			// biome-ignore lint/suspicious/noExplicitAny: nor mocked the full type
+		} as any);
+
+		mockUseWriteContract.mockReturnValue({
+			writeContractAsync: mockWriteContractAsync,
+			data: undefined,
+			isPending: false,
+			isError: false,
+			isSuccess: false,
+			error: null,
+			status: 'idle',
+			variables: undefined,
+			isIdle: true,
+			reset: vi.fn(),
+			context: undefined,
+			failureCount: 0,
+			failureReason: null,
+			isPaused: false,
+			submittedAt: 0,
+		} as any);
+	});
+
+	describe('Hook Return Values', () => {
+		it('should return correct interface', () => {
+			const { result } = renderHook(() => useTransferTokens());
+
+			expect(result.current).toHaveProperty('transferTokensAsync');
+			expect(result.current).toHaveProperty('hash');
+			expect(result.current).toHaveProperty('transferring');
+			expect(result.current).toHaveProperty('transferFailed');
+			expect(result.current).toHaveProperty('transferSuccess');
+			expect(typeof result.current.transferTokensAsync).toBe('function');
+		});
+
+		it('should return wagmi hook states correctly', () => {
+			mockUseWriteContract.mockReturnValue({
+				writeContractAsync: mockWriteContractAsync,
+				data: '0xhash123' as `0x${string}`,
+				isPending: true,
+				isError: false,
+				isSuccess: false,
+				error: null,
+				status: 'pending',
+				variables: undefined,
+				isIdle: false,
+				reset: vi.fn(),
+				context: undefined,
+				failureCount: 0,
+				failureReason: null,
+				isPaused: false,
+				submittedAt: 0,
+			} as any);
+
+			const { result } = renderHook(() => useTransferTokens());
+
+			expect(result.current.hash).toBe('0xhash123');
+			expect(result.current.transferring).toBe(true);
+			expect(result.current.transferFailed).toBe(false);
+			expect(result.current.transferSuccess).toBe(false);
+		});
+	});
+
+	describe('ERC721 Transfers', () => {
+		const erc721Params: TransferTokensParams = {
+			contractType: ContractType.ERC721,
+			chainId: 1,
+			collectionAddress: mockCollectionAddress,
+			tokenId: '123',
+			receiverAddress: mockReceiverAddress,
+		};
+
+		it('should prepare correct ERC721 transfer config', async () => {
+			mockWriteContractAsync.mockResolvedValue('0xhash123');
+
+			const { result } = renderHook(() => useTransferTokens());
+
+			await result.current.transferTokensAsync(erc721Params);
+
+			expect(mockWriteContractAsync).toHaveBeenCalledWith({
+				abi: expect.any(Array), // erc721Abi
+				address: mockCollectionAddress,
+				functionName: 'safeTransferFrom',
+				args: [mockAccountAddress, mockReceiverAddress, BigInt('123')],
+			});
+		});
+
+		it('should return transaction hash for ERC721', async () => {
+			const expectedHash = '0xabc123def456';
+			mockWriteContractAsync.mockResolvedValue(expectedHash);
+
+			const { result } = renderHook(() => useTransferTokens());
+
+			const hash = await result.current.transferTokensAsync(erc721Params);
+
+			expect(hash).toBe(expectedHash);
+		});
+
+		it('should handle ERC721 transfer errors', async () => {
+			const error = new Error('Transfer failed');
+			mockWriteContractAsync.mockRejectedValue(error);
+
+			const { result } = renderHook(() => useTransferTokens());
+
+			await expect(
+				result.current.transferTokensAsync(erc721Params),
+			).rejects.toThrow('Transfer failed');
+		});
+	});
+
+	describe('ERC1155 Transfers', () => {
+		const erc1155Params: TransferTokensParams = {
+			contractType: ContractType.ERC1155,
+			chainId: 1,
+			collectionAddress: mockCollectionAddress,
+			tokenId: '456',
+			receiverAddress: mockReceiverAddress,
+			quantity: '5',
+		};
+
+		it('should prepare correct ERC1155 transfer config', async () => {
+			mockWriteContractAsync.mockResolvedValue('0xhash456');
+
+			const { result } = renderHook(() => useTransferTokens());
+
+			await result.current.transferTokensAsync(erc1155Params);
+
+			expect(mockWriteContractAsync).toHaveBeenCalledWith({
+				abi: expect.any(Array), // ERC1155_ABI
+				address: mockCollectionAddress,
+				functionName: 'safeTransferFrom',
+				args: [
+					mockAccountAddress,
+					mockReceiverAddress,
+					BigInt('456'),
+					'5',
+					'0x', // data
+				],
+			});
+		});
+
+		it('should return transaction hash for ERC1155', async () => {
+			const expectedHash = '0xdef789ghi012';
+			mockWriteContractAsync.mockResolvedValue(expectedHash);
+
+			const { result } = renderHook(() => useTransferTokens());
+
+			const hash = await result.current.transferTokensAsync(erc1155Params);
+
+			expect(hash).toBe(expectedHash);
+		});
+
+		it('should handle ERC1155 transfer errors', async () => {
+			const error = new Error('ERC1155 transfer failed');
+			mockWriteContractAsync.mockRejectedValue(error);
+
+			const { result } = renderHook(() => useTransferTokens());
+
+			await expect(
+				result.current.transferTokensAsync(erc1155Params),
+			).rejects.toThrow('ERC1155 transfer failed');
+		});
+
+		it('should handle different quantity values', async () => {
+			mockWriteContractAsync.mockResolvedValue('0xhash');
+
+			const { result } = renderHook(() => useTransferTokens());
+
+			// Test with large quantity
+			await result.current.transferTokensAsync({
+				...erc1155Params,
+				quantity: '1000000',
+			});
+
+			expect(mockWriteContractAsync).toHaveBeenCalledWith(
+				expect.objectContaining({
+					args: expect.arrayContaining(['1000000']),
+				}),
+			);
+		});
+	});
+
+	describe('Error Handling', () => {
+		it('should throw NoWalletConnectedError when no account address', async () => {
+			mockUseAccount.mockReturnValue({
+				address: undefined,
+				chainId: 1,
+				addresses: undefined,
+				chain: undefined,
+				connector: undefined,
+				isConnected: false,
+				isConnecting: false,
+				isDisconnected: true,
+				isReconnecting: false,
+				status: 'disconnected',
+			} as any);
+
+			const { result } = renderHook(() => useTransferTokens());
+
+			const erc721Params: TransferTokensParams = {
+				contractType: ContractType.ERC721,
+				chainId: 1,
+				collectionAddress: mockCollectionAddress,
+				tokenId: '123',
+				receiverAddress: mockReceiverAddress,
+			};
+
+			await expect(
+				result.current.transferTokensAsync(erc721Params),
+			).rejects.toThrow(NoWalletConnectedError);
+		});
+
+		it('should not call writeContractAsync when no wallet connected', async () => {
+			mockUseAccount.mockReturnValue({
+				address: undefined,
+				chainId: 1,
+				addresses: undefined,
+				chain: undefined,
+				connector: undefined,
+				isConnected: false,
+				isConnecting: false,
+				isDisconnected: true,
+				isReconnecting: false,
+				status: 'disconnected',
+			} as any);
+
+			const { result } = renderHook(() => useTransferTokens());
+
+			const erc721Params: TransferTokensParams = {
+				contractType: ContractType.ERC721,
+				chainId: 1,
+				collectionAddress: mockCollectionAddress,
+				tokenId: '123',
+				receiverAddress: mockReceiverAddress,
+			};
+
+			try {
+				await result.current.transferTokensAsync(erc721Params);
+			} catch {
+				// Expected to throw
+			}
+
+			expect(mockWriteContractAsync).not.toHaveBeenCalled();
+		});
+	});
+
+	describe('State Updates', () => {
+		it('should reflect isPending state', () => {
+			mockUseWriteContract.mockReturnValue({
+				writeContractAsync: mockWriteContractAsync,
+				data: undefined,
+				isPending: true,
+				isError: false,
+				isSuccess: false,
+				error: null,
+				status: 'pending',
+				variables: undefined,
+				isIdle: false,
+				reset: vi.fn(),
+				context: undefined,
+				failureCount: 0,
+				failureReason: null,
+				isPaused: false,
+				submittedAt: 0,
+			} as any);
+
+			const { result } = renderHook(() => useTransferTokens());
+
+			expect(result.current.transferring).toBe(true);
+		});
+
+		it('should reflect isError state', () => {
+			mockUseWriteContract.mockReturnValue({
+				writeContractAsync: mockWriteContractAsync,
+				data: undefined,
+				isPending: false,
+				isError: true,
+				isSuccess: false,
+				error: new Error('Contract error'),
+				status: 'error',
+				variables: undefined,
+				isIdle: false,
+				reset: vi.fn(),
+				context: undefined,
+				failureCount: 1,
+				failureReason: new Error('Contract error'),
+				isPaused: false,
+				submittedAt: 0,
+			} as any);
+
+			const { result } = renderHook(() => useTransferTokens());
+
+			expect(result.current.transferFailed).toBe(true);
+		});
+
+		it('should reflect isSuccess state', () => {
+			mockUseWriteContract.mockReturnValue({
+				writeContractAsync: mockWriteContractAsync,
+				data: '0xsuccess123' as `0x${string}`,
+				isPending: false,
+				isError: false,
+				isSuccess: true,
+				error: null,
+				status: 'success',
+				variables: undefined,
+				isIdle: false,
+				reset: vi.fn(),
+				context: undefined,
+				failureCount: 0,
+				failureReason: null,
+				isPaused: false,
+				submittedAt: 0,
+			} as any);
+
+			const { result } = renderHook(() => useTransferTokens());
+
+			expect(result.current.transferSuccess).toBe(true);
+			expect(result.current.hash).toBe('0xsuccess123');
+		});
+	});
+
+	describe('Integration with Wagmi Mocks', () => {
+		it('should work with wagmi test configuration', () => {
+			// This test verifies the hook works with our existing wagmi mock setup
+			const { result } = renderHook(() => useTransferTokens(), {
+				useEmbeddedWallet: false, // Use standard mock connector
+			});
+
+			expect(result.current.transferTokensAsync).toBeDefined();
+			expect(typeof result.current.transferTokensAsync).toBe('function');
+		});
+
+		it('should work with WaaS wallet configuration', () => {
+			const { result } = renderHook(() => useTransferTokens(), {
+				useEmbeddedWallet: true, // Use WaaS mock connector
+			});
+
+			expect(result.current.transferTokensAsync).toBeDefined();
+			expect(typeof result.current.transferTokensAsync).toBe('function');
+		});
+	});
+
+	describe('Contract Interaction', () => {
+		it('should handle contract call success', async () => {
+			const expectedHash = '0xcontract123success';
+			mockWriteContractAsync.mockResolvedValue(expectedHash);
+
+			const { result } = renderHook(() => useTransferTokens());
+
+			const erc721Params: TransferTokensParams = {
+				contractType: ContractType.ERC721,
+				chainId: 1,
+				collectionAddress: mockCollectionAddress,
+				tokenId: '789',
+				receiverAddress: mockReceiverAddress,
+			};
+
+			const hash = await result.current.transferTokensAsync(erc721Params);
+
+			expect(hash).toBe(expectedHash);
+			expect(mockWriteContractAsync).toHaveBeenCalledTimes(1);
+		});
+
+		it('should handle contract call failure', async () => {
+			const contractError = new Error('Contract execution reverted');
+			mockWriteContractAsync.mockRejectedValue(contractError);
+
+			const { result } = renderHook(() => useTransferTokens());
+
+			const erc721Params: TransferTokensParams = {
+				contractType: ContractType.ERC721,
+				chainId: 1,
+				collectionAddress: mockCollectionAddress,
+				tokenId: '789',
+				receiverAddress: mockReceiverAddress,
+			};
+
+			await expect(
+				result.current.transferTokensAsync(erc721Params),
+			).rejects.toThrow('Contract execution reverted');
+		});
+	});
+
+	describe('Parameter Validation', () => {
+		it('should handle different token ID formats', async () => {
+			mockWriteContractAsync.mockResolvedValue('0xhash');
+
+			const { result } = renderHook(() => useTransferTokens());
+
+			// Test with string token ID
+			await result.current.transferTokensAsync({
+				contractType: ContractType.ERC721,
+				chainId: 1,
+				collectionAddress: mockCollectionAddress,
+				tokenId: '999999999999999999999',
+				receiverAddress: mockReceiverAddress,
+			});
+
+			expect(mockWriteContractAsync).toHaveBeenCalledWith(
+				expect.objectContaining({
+					args: expect.arrayContaining([BigInt('999999999999999999999')]),
+				}),
+			);
+		});
+
+		it('should handle different chain IDs', async () => {
+			mockWriteContractAsync.mockResolvedValue('0xhash');
+
+			const { result } = renderHook(() => useTransferTokens());
+
+			const polygonParams: TransferTokensParams = {
+				contractType: ContractType.ERC721,
+				chainId: 137, // Polygon
+				collectionAddress: mockCollectionAddress,
+				tokenId: '123',
+				receiverAddress: mockReceiverAddress,
+			};
+
+			await result.current.transferTokensAsync(polygonParams);
+
+			expect(mockWriteContractAsync).toHaveBeenCalled();
+		});
+	});
+});

package/src/react/hooks/index.ts

@@ -1,47 +1,52 @@
 export * from './useAutoSelectFeeOption';
 export * from './useBalanceOfCollectible';
-export * from './useCountOfCollectables';
+export * from './useCancelOrder';
+export * from './useCheckoutOptionsSalesContract';
+export * from './useCheckoutOptionsSalesContract';
 export * from './useCollectible';
 export * from './useCollection';
 export * from './useCollectionBalanceDetails';
+export * from './useCollectionDetails';
+export * from './useCollectionDetailsPolling';
 export * from './useComparePrices';
 export * from './useConfig';
 export * from './useConvertPriceToUSD';
-export * from './useMarketCurrencies';
+export * from './useCountListingsForCollectible';
+export * from './useCountOfCollectables';
+export * from './useCountOffersForCollectible';
+export * from './useCountOfPrimarySaleItems';
 export * from './useCurrency';
-export * from './useFilters';
+export * from './useERC721SaleMintedTokens';
 export * from './useFilterState';
+export * from './useFilters';
 export * from './useFloorOrder';
+export * from './useGenerateCancelTransaction';
+export * from './useGenerateListingTransaction';
+export * from './useGenerateOfferTransaction';
+export * from './useGenerateSellTransaction';
+export * from './useGetCountOfPrimarySaleItems';
+export * from './useGetTokenRanges';
 export * from './useHighestOffer';
 export * from './useInventory';
+export * from './useList721ShopCardData';
+export * from './useList1155ShopCardData';
 export * from './useListBalances';
 export * from './useListCollectibleActivities';
 export * from './useListCollectibles';
 export * from './useListCollectiblesPaginated';
 export * from './useListCollectionActivities';
-export * from './useListOffersForCollectible';
-export * from './useCountOffersForCollectible';
+export * from './useListCollections';
 export * from './useListListingsForCollectible';
-export * from './useCountListingsForCollectible';
+export * from './useListMarketCardData';
+export * from './useListOffersForCollectible';
+export * from './useListPrimarySaleItems';
+export * from './useListShopCardData';
+export * from './useListTokenMetadata';
 export * from './useLowestListing';
+export * from './useMarketCurrencies';
 export * from './useMarketplaceConfig';
+export * from './useOpenConnectModal';
 export * from './useRoyalty';
-export * from './useGenerateListingTransaction';
-export * from './useGenerateOfferTransaction';
-export * from './useGenerateSellTransaction';
-export * from './useGenerateCancelTransaction';
+export * from './useShopCollectibleSaleData';
+export * from './useTokenSupplies';
 export * from './useTransferTokens';
-export * from './useCheckoutOptions';
-export * from './useCheckoutOptionsSalesContract';
-export * from './useListCollections';
-export * from './useCancelOrder';
-export * from './useCollectionDetails';
-export * from './useCollectionDetailsPolling';
-export * from './useListTokenMetadata';
-export * from './useList1155ShopCardData';
-export * from './useList721ShopCardData';
-export * from './useListMarketCardData';
-export * from './useGetTokenSuppliesMap';
-export * from './useListPrimarySaleItems';
-export * from './useERC721SaleMintedTokens';
-export * from './useCheckoutOptionsSalesContract';

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

@@ -1,2 +1 @@
-export { fetchCollection, collectionOptions } from './collectionOptions';
 export * from '../../queries/marketplaceConfig';

package/src/react/hooks/useAutoSelectFeeOption.tsx

@@ -1,8 +1,8 @@
 'use client';
-import { type Address, zeroAddress } from 'viem';
 
 import { useChain } from '@0xsequence/connect';
 import { useCallback, useEffect } from 'react';
+import { type Address, zeroAddress } from 'viem';
 import { useAccount } from 'wagmi';
 import type { FeeOption } from '../../types/waas-types';
 import { useCollectionBalanceDetails } from './useCollectionBalanceDetails';

package/src/react/hooks/useBalanceOfCollectible.tsx

@@ -1,8 +1,8 @@
 import { useQuery } from '@tanstack/react-query';
 import { ContractType } from '../_internal';
 import {
-	type UseBalanceOfCollectibleArgs,
 	balanceOfCollectibleOptions,
+	type UseBalanceOfCollectibleArgs,
 } from '../queries/balanceOfCollectible';
 import { useConfig } from './useConfig';
 import { useMarketplaceConfig } from './useMarketplaceConfig';

package/src/react/hooks/useCancelTransactionSteps.tsx

@@ -5,11 +5,11 @@ import {
 } from '../../utils/_internal/error/transaction';
 import {
 	ExecuteType,
+	getMarketplaceClient,
+	getQueryClient,
 	type MarketplaceKind,
 	type Step,
 	StepType,
-	getMarketplaceClient,
-	getQueryClient,
 } from '../_internal';
 import type {
 	SignatureStep,