@0xsequence/marketplace-sdk 0.5.2 → 0.5.4

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

@@ -0,0 +1,410 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { renderHook, waitFor } from '../../_internal/test-utils';
+import { useCancelOrder } from '../useCancelOrder';
+import { MarketplaceKind } from '../../../types';
+import { server } from '../../_internal/test/setup';
+import { http, HttpResponse } from 'msw';
+import { mockMarketplaceEndpoint } from '../../_internal/api/__mocks__/marketplace.msw';
+import { useWallet } from '../../_internal/wallet/useWallet';
+import {
+	createMockWallet,
+	commonWalletMocks,
+} from '../../_internal/test/mocks/wallet';
+import { StepType } from '../../_internal/api/marketplace.gen';
+
+// Mock useWallet hook
+vi.mock('../../_internal/wallet/useWallet');
+
+// Mock @0xsequence/kit
+vi.mock('@0xsequence/kit', () => ({
+	useWaasFeeOptions: () => [null, vi.fn()],
+	useChain: () => ({
+		id: 1,
+		name: 'Ethereum',
+		nativeCurrency: {
+			name: 'Ether',
+			symbol: 'ETH',
+			decimals: 18,
+		},
+	}),
+}));
+
+// Mock wagmi
+vi.mock('wagmi', () => ({
+	useAccount: () => ({
+		address: '0x1234567890123456789012345678901234567890',
+		isConnected: true,
+	}),
+	createConfig: () => ({
+		chains: [
+			{
+				id: 1,
+				name: 'Ethereum',
+				nativeCurrency: {
+					name: 'Ether',
+					symbol: 'ETH',
+					decimals: 18,
+				},
+			},
+		],
+		connectors: [],
+		transports: {},
+	}),
+	http: () => ({}),
+	WagmiProvider: ({ children }: { children: React.ReactNode }) => children,
+}));
+
+describe('useCancelOrder', () => {
+	const defaultProps = {
+		collectionAddress: '0x1234567890123456789012345678901234567890',
+		chainId: '1',
+	};
+
+	const mockOrderId = '0x9876543210987654321098765432109876543210';
+	const mockTxHash = '0xabcd1234';
+
+	// Create mock wallet instance with custom implementations
+	const mockWallet = createMockWallet({
+		getChainId: vi.fn().mockResolvedValue(1),
+		address: vi
+			.fn()
+			.mockResolvedValue('0x1234567890123456789012345678901234567890'),
+		handleSendTransactionStep: vi.fn().mockResolvedValue(mockTxHash),
+		handleSignMessageStep: vi.fn().mockResolvedValue('0xsignature'),
+		handleConfirmTransactionStep: vi.fn().mockResolvedValue(undefined),
+		isWaaS: true,
+		switchChain: vi.fn().mockResolvedValue(undefined),
+	});
+
+	beforeEach(() => {
+		vi.clearAllMocks();
+
+		// Set up the mock implementation for useWallet
+		vi.mocked(useWallet).mockReturnValue({
+			wallet: mockWallet,
+			isLoading: false,
+			isError: false,
+		});
+
+		// Mock default steps response
+		server.use(
+			http.post(mockMarketplaceEndpoint('GenerateCancelTransaction'), () => {
+				return HttpResponse.json({
+					steps: [
+						{
+							id: StepType.cancel,
+							data: '0x...',
+							to: defaultProps.collectionAddress,
+							value: '0',
+							executeType: 'order',
+						},
+					],
+				});
+			}),
+			http.post(mockMarketplaceEndpoint('Execute'), () => {
+				return HttpResponse.json({
+					orderId: mockOrderId,
+					hash: mockTxHash,
+				});
+			}),
+			http.post('*/GetTokenBalancesDetails', () => {
+				return HttpResponse.json({
+					page: { page: 1, pageSize: 10, more: false },
+					balances: [],
+					nativeBalances: [
+						{
+							balance: '2000000000000000000', // 2 ETH
+							blockHash: '0x1234',
+							blockNumber: 1234567,
+						},
+					],
+				});
+			}),
+		);
+	});
+
+	afterEach(() => {
+		server.resetHandlers();
+		vi.clearAllMocks();
+	});
+
+	it('should initialize with default state', () => {
+		const { result } = renderHook(() => useCancelOrder(defaultProps));
+
+		expect(result.current.isExecuting).toBe(false);
+		expect(result.current.cancellingOrderId).toBeNull();
+	});
+
+	it('should handle cancellation error', async () => {
+		const onError = vi.fn();
+
+		server.use(
+			http.post(mockMarketplaceEndpoint('GenerateCancelTransaction'), () => {
+				return HttpResponse.error();
+			}),
+		);
+
+		const { result } = renderHook(() =>
+			useCancelOrder({
+				...defaultProps,
+				onError,
+			}),
+		);
+
+		try {
+			await result.current.cancelOrder({
+				orderId: mockOrderId,
+				marketplace: MarketplaceKind.sequence_marketplace_v2,
+			});
+		} catch (error) {
+			// Error is expected
+		}
+
+		await waitFor(() => {
+			expect(onError).toHaveBeenCalled();
+			expect(result.current.cancellingOrderId).toBeNull();
+			expect(result.current.isExecuting).toBe(false);
+		});
+	});
+
+	it('should update state during cancellation process', async () => {
+		const { result } = renderHook(() => useCancelOrder(defaultProps));
+
+		// Mock a delayed response
+		server.use(
+			http.post(mockMarketplaceEndpoint('GenerateCancelTransaction'), () => {
+				return new Promise((resolve) =>
+					setTimeout(
+						() =>
+							resolve(
+								HttpResponse.json({
+									steps: [
+										{
+											id: StepType.cancel,
+											data: '0x...',
+											to: defaultProps.collectionAddress,
+											value: '0',
+											executeType: 'order',
+										},
+									],
+								}),
+							),
+						100,
+					),
+				);
+			}),
+		);
+
+		// Start the cancellation
+		const cancelPromise = result.current.cancelOrder({
+			orderId: mockOrderId,
+			marketplace: MarketplaceKind.sequence_marketplace_v2,
+		});
+
+		// Wait for immediate state updates
+		await waitFor(() => {
+			expect(result.current.cancellingOrderId).toBe(mockOrderId);
+		});
+
+		// Wait for execution state to be true
+		await waitFor(() => {
+			expect(result.current.isExecuting).toBe(true);
+		});
+
+		// Wait for the cancellation to complete
+		await cancelPromise;
+	});
+
+	it('should handle chain switching failure', async () => {
+		const onError = vi.fn();
+
+		// Mock wallet to fail chain switch
+		const mockWalletWithFailedChainSwitch = createMockWallet({
+			...commonWalletMocks,
+			getChainId: vi.fn().mockResolvedValue(2), // Different chain than required
+			switchChain: vi
+				.fn()
+				.mockRejectedValue(new Error('Failed to switch chain')),
+			isWaaS: true,
+		});
+
+		vi.mocked(useWallet).mockReturnValue({
+			wallet: mockWalletWithFailedChainSwitch,
+			isLoading: false,
+			isError: false,
+		});
+
+		const { result } = renderHook(() =>
+			useCancelOrder({
+				...defaultProps,
+				onError,
+			}),
+		);
+
+		try {
+			await result.current.cancelOrder({
+				orderId: mockOrderId,
+				marketplace: MarketplaceKind.sequence_marketplace_v2,
+			});
+		} catch (error) {
+			// Error is expected
+		}
+
+		await waitFor(() => {
+			expect(onError).toHaveBeenCalledWith(expect.any(Error));
+			expect(mockWalletWithFailedChainSwitch.switchChain).toHaveBeenCalledWith(
+				1,
+			);
+			expect(result.current.cancellingOrderId).toBeNull();
+			expect(result.current.isExecuting).toBe(false);
+		});
+	});
+
+	it('should handle transaction confirmation failure', async () => {
+		const onError = vi.fn();
+
+		// Mock wallet with failed transaction confirmation
+		const mockWalletWithFailedConfirmation = createMockWallet({
+			...commonWalletMocks,
+			getChainId: vi.fn().mockResolvedValue(1),
+			handleSendTransactionStep: vi.fn().mockResolvedValue(mockTxHash),
+			handleSignMessageStep: vi.fn().mockResolvedValue('0xsignature'),
+			handleConfirmTransactionStep: vi
+				.fn()
+				.mockRejectedValue(new Error('Transaction confirmation failed')),
+			isWaaS: true,
+		});
+
+		vi.mocked(useWallet).mockReturnValue({
+			wallet: mockWalletWithFailedConfirmation,
+			isLoading: false,
+			isError: false,
+		});
+
+		const { result } = renderHook(() =>
+			useCancelOrder({
+				...defaultProps,
+				onError,
+			}),
+		);
+
+		try {
+			await result.current.cancelOrder({
+				orderId: mockOrderId,
+				marketplace: MarketplaceKind.sequence_marketplace_v2,
+			});
+		} catch (error) {
+			// Error is expected
+		}
+
+		await waitFor(() => {
+			expect(onError).toHaveBeenCalledWith(expect.any(Error));
+			expect(
+				mockWalletWithFailedConfirmation.handleConfirmTransactionStep,
+			).toHaveBeenCalled();
+			expect(result.current.cancellingOrderId).toBeNull();
+			expect(result.current.isExecuting).toBe(false);
+		});
+	});
+
+	it('should successfully cancel an order', async () => {
+		const onSuccess = vi.fn();
+
+		// Mock successful responses for all steps
+		server.use(
+			http.post(mockMarketplaceEndpoint('GenerateCancelTransaction'), () => {
+				return new Promise((resolve) =>
+					setTimeout(
+						() =>
+							resolve(
+								HttpResponse.json({
+									steps: [
+										{
+											id: StepType.cancel,
+											data: '0x1234',
+											to: defaultProps.collectionAddress,
+											value: '0',
+											executeType: 'order',
+										},
+									],
+								}),
+							),
+						50,
+					),
+				);
+			}),
+			http.post(mockMarketplaceEndpoint('Execute'), () => {
+				return HttpResponse.json({
+					hash: mockTxHash,
+				});
+			}),
+		);
+
+		const mockSuccessWallet = createMockWallet({
+			...commonWalletMocks,
+			getChainId: vi.fn().mockResolvedValue(1),
+			handleSendTransactionStep: vi.fn().mockResolvedValue(mockTxHash),
+			handleSignMessageStep: vi.fn().mockResolvedValue('0xsignature'),
+			handleConfirmTransactionStep: vi.fn().mockResolvedValue(undefined),
+			isWaaS: true,
+		});
+
+		vi.mocked(useWallet).mockReturnValue({
+			wallet: mockSuccessWallet,
+			isLoading: false,
+			isError: false,
+		});
+
+		const { result } = renderHook(() =>
+			useCancelOrder({
+				...defaultProps,
+				onSuccess,
+			}),
+		);
+
+		// Start the cancellation
+		result.current.cancelOrder({
+			orderId: mockOrderId,
+			marketplace: MarketplaceKind.sequence_marketplace_v2,
+		});
+
+		// First, wait for the orderId to be set
+		await waitFor(
+			() => {
+				expect(result.current.cancellingOrderId).toBe(mockOrderId);
+			},
+			{ timeout: 1000 },
+		);
+
+		// Then wait for execution to start
+		await waitFor(
+			() => {
+				expect(result.current.isExecuting).toBe(true);
+			},
+			{ timeout: 1000 },
+		);
+
+		// Wait for the success callback to be called
+		await waitFor(
+			() => {
+				expect(onSuccess).toHaveBeenCalledWith({
+					hash: mockTxHash,
+				});
+			},
+			{ timeout: 1000 },
+		);
+
+		// Finally verify the states are reset
+		await waitFor(
+			() => {
+				expect(mockSuccessWallet.handleSendTransactionStep).toHaveBeenCalled();
+				expect(
+					mockSuccessWallet.handleConfirmTransactionStep,
+				).toHaveBeenCalled();
+				expect(result.current.cancellingOrderId).toBeNull();
+				expect(result.current.isExecuting).toBe(false);
+			},
+			{ timeout: 1000 },
+		);
+	});
+});

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

@@ -0,0 +1,269 @@
+import { describe, expect, it, vi, beforeEach, afterEach } from 'vitest';
+import { useCancelTransactionSteps } from '../useCancelTransactionSteps';
+import { renderHook, waitFor } from '../../_internal/test-utils';
+import { zeroAddress } from 'viem';
+import { http, HttpResponse } from 'msw';
+import {
+	mockSteps,
+	mockMarketplaceEndpoint,
+} from '../../_internal/api/__mocks__/marketplace.msw';
+import { server } from '../../_internal/test/setup';
+import { MarketplaceKind, StepType } from '../../_internal/api/marketplace.gen';
+import {
+	ChainSwitchUserRejectedError,
+	WalletInstanceNotFoundError,
+} from '../../../utils/_internal/error/transaction';
+import { useWallet } from '../../_internal/wallet/useWallet';
+import {
+	createMockWallet,
+	commonWalletMocks,
+} from '../../_internal/test/mocks/wallet';
+
+// Create mock wallet instance with default successful implementations
+const mockWallet = createMockWallet({
+	getChainId: commonWalletMocks.successfulChainId,
+	address: commonWalletMocks.successfulAddress,
+	handleSendTransactionStep: commonWalletMocks.successfulTransaction,
+	handleSignMessageStep: commonWalletMocks.successfulSignature,
+	handleConfirmTransactionStep: commonWalletMocks.successfulConfirmation,
+});
+
+// Mock useWallet hook
+vi.mock('../../_internal/wallet/useWallet');
+
+// Mock switch chain modal
+vi.mock('../../ui/modals/_internal/components/switchChainModal', () => ({
+	useSwitchChainModal: () => ({
+		show: vi.fn((args) => args.onSuccess()),
+	}),
+}));
+
+describe('useCancelTransactionSteps', () => {
+	const mockSetSteps = vi.fn();
+	const mockOnSuccess = vi.fn();
+	const mockOnError = vi.fn();
+
+	const defaultArgs = {
+		chainId: '1',
+		collectionAddress: zeroAddress,
+		setSteps: mockSetSteps,
+		onSuccess: mockOnSuccess,
+		onError: mockOnError,
+	};
+
+	beforeEach(() => {
+		vi.clearAllMocks();
+
+		// Set up the mock implementation for useWallet in beforeEach
+		vi.mocked(useWallet).mockReturnValue({
+			wallet: mockWallet,
+			isLoading: false,
+			isError: false,
+		});
+
+		// Mock default steps response
+		server.use(
+			http.post(mockMarketplaceEndpoint('GenerateCancelTransaction'), () => {
+				return HttpResponse.json({
+					steps: [
+						{
+							...mockSteps[0],
+							id: StepType.cancel,
+						},
+					],
+				});
+			}),
+		);
+	});
+
+	afterEach(() => {
+		server.resetHandlers();
+	});
+
+	it('should handle transaction steps successfully', async () => {
+		const { result } = renderHook(() => useCancelTransactionSteps(defaultArgs));
+
+		await result.current.cancelOrder({
+			orderId: '123',
+			marketplace: MarketplaceKind.sequence_marketplace_v2,
+		});
+
+		// Verify that setSteps was called with a function that sets isExecuting to true
+		const setStepsCall = mockSetSteps.mock.calls[0][0];
+		expect(typeof setStepsCall).toBe('function');
+		const updatedState = setStepsCall({ isExecuting: false });
+		expect(updatedState.isExecuting).toBe(true);
+
+		expect(mockOnSuccess).toHaveBeenCalled();
+		expect(mockOnError).not.toHaveBeenCalled();
+	});
+
+	it('should handle signature steps successfully', async () => {
+		// Mock steps to include signature step
+		server.use(
+			http.post(mockMarketplaceEndpoint('GenerateCancelTransaction'), () => {
+				return HttpResponse.json({
+					steps: [
+						{
+							...mockSteps[0],
+							id: StepType.signEIP712,
+						},
+					],
+				});
+			}),
+		);
+
+		const { result } = renderHook(() => useCancelTransactionSteps(defaultArgs));
+
+		await result.current.cancelOrder({
+			orderId: '123',
+			marketplace: MarketplaceKind.sequence_marketplace_v2,
+		});
+
+		expect(mockWallet.handleSignMessageStep).toHaveBeenCalled();
+		expect(mockOnSuccess).toHaveBeenCalled();
+		expect(mockOnError).not.toHaveBeenCalled();
+	});
+
+	it('should handle chain switching', async () => {
+		// Mock different chain ID
+		commonWalletMocks.successfulChainId.mockResolvedValueOnce(2);
+
+		const { result } = renderHook(() => useCancelTransactionSteps(defaultArgs));
+
+		await result.current.cancelOrder({
+			orderId: '123',
+			marketplace: MarketplaceKind.sequence_marketplace_v2,
+		});
+
+		expect(mockWallet.getChainId).toHaveBeenCalled();
+
+		waitFor(() => {
+			expect(mockWallet.switchChain).toHaveBeenCalled();
+
+			expect(mockOnSuccess).toHaveBeenCalled();
+			expect(mockOnError).not.toHaveBeenCalled();
+		});
+	});
+
+	it('should handle wallet not initialized error', async () => {
+		// Override the mock for this specific test
+		vi.mocked(useWallet).mockReturnValue({
+			wallet: null,
+			isLoading: false,
+			isError: false,
+		});
+
+		const { result } = renderHook(() => useCancelTransactionSteps(defaultArgs));
+
+		try {
+			await result.current.cancelOrder({
+				orderId: '123',
+				marketplace: MarketplaceKind.sequence_marketplace_v2,
+			});
+		} catch (error) {
+			expect(error).toBeInstanceOf(WalletInstanceNotFoundError);
+		}
+
+		expect(mockOnSuccess).not.toHaveBeenCalled();
+	});
+
+	it('should handle chain switch rejection', async () => {
+		// Create a new mock wallet with chain switch rejection
+		const mockWalletWithRejection = createMockWallet({
+			...mockWallet,
+			getChainId: vi.fn().mockResolvedValue(2),
+			switchChain: commonWalletMocks.chainSwitchRejection,
+		});
+
+		// Override the mock for this specific test
+		vi.mocked(useWallet).mockReturnValue({
+			wallet: mockWalletWithRejection,
+			isLoading: false,
+			isError: false,
+		});
+
+		// Mock switch chain modal to reject
+		vi.mock('../../ui/modals/_internal/components/switchChainModal', () => ({
+			useSwitchChainModal: () => ({
+				show: vi.fn((args) => args.onClose()),
+			}),
+		}));
+
+		const { result } = renderHook(() =>
+			useCancelTransactionSteps({
+				...defaultArgs,
+				callbacks: {
+					onError: mockOnError,
+				},
+			}),
+		);
+
+		await result.current.cancelOrder({
+			orderId: '123',
+			marketplace: MarketplaceKind.sequence_marketplace_v2,
+		});
+
+		expect(mockOnError).toHaveBeenCalledWith(
+			expect.any(ChainSwitchUserRejectedError),
+		);
+		expect(mockOnSuccess).not.toHaveBeenCalled();
+	});
+
+	it('should handle transaction failure', async () => {
+		// Create a new mock wallet with transaction failure
+		const mockWalletWithFailure = createMockWallet({
+			...mockWallet,
+			handleSendTransactionStep: commonWalletMocks.transactionFailure,
+		});
+
+		// Override the mock for this specific test
+		vi.mocked(useWallet).mockReturnValue({
+			wallet: mockWalletWithFailure,
+			isLoading: false,
+			isError: false,
+		});
+
+		const { result } = renderHook(() => useCancelTransactionSteps(defaultArgs));
+
+		await result.current.cancelOrder({
+			orderId: '123',
+			marketplace: MarketplaceKind.sequence_marketplace_v2,
+		});
+
+		// Verify that setSteps was called with a function that sets isExecuting to false
+		const setStepsCall =
+			mockSetSteps.mock.calls[mockSetSteps.mock.calls.length - 1][0];
+		expect(typeof setStepsCall).toBe('function');
+		const updatedState = setStepsCall({ isExecuting: true });
+		expect(updatedState.isExecuting).toBe(false);
+
+		expect(mockOnError).toHaveBeenCalledWith(expect.any(Error));
+		expect(mockOnSuccess).not.toHaveBeenCalled();
+	});
+
+	it('should handle missing steps error', async () => {
+		// Mock empty steps response
+		server.use(
+			http.post(mockMarketplaceEndpoint('GenerateCancelTransaction'), () => {
+				return HttpResponse.json({
+					steps: [],
+				});
+			}),
+		);
+
+		const { result } = renderHook(() => useCancelTransactionSteps(defaultArgs));
+
+		await result.current.cancelOrder({
+			orderId: '123',
+			marketplace: MarketplaceKind.sequence_marketplace_v2,
+		});
+
+		expect(mockOnError).toHaveBeenCalledWith(
+			expect.objectContaining({
+				message: 'No transaction or signature step found',
+			}),
+		);
+		expect(mockOnSuccess).not.toHaveBeenCalled();
+	});
+});