@0xsequence/marketplace-sdk 0.5.1 → 0.5.3

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

@@ -0,0 +1,207 @@
+import { describe, expect, it, vi, beforeEach } from 'vitest';
+import {
+	commonWagmiMocks,
+	mockChains,
+	mockConnectors,
+} from '../../_internal/test/mocks/wagmi';
+
+// Mock wagmi
+vi.mock('wagmi', () => ({
+	useAccount: commonWagmiMocks.useAccount,
+	createConfig: commonWagmiMocks.createConfig,
+	http: commonWagmiMocks.http,
+	WagmiProvider: commonWagmiMocks.WagmiProvider,
+}));
+
+// Mock wagmi/chains
+vi.mock('wagmi/chains', () => mockChains);
+
+// Mock wagmi/connectors
+vi.mock('wagmi/connectors', () => mockConnectors);
+
+// Mock useConfig hook
+vi.mock('../useConfig', () => ({
+	useConfig: vi.fn(),
+}));
+
+import { useGenerateCancelTransaction } from '../useGenerateCancelTransaction';
+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 } from '../../_internal/api/marketplace.gen';
+import { useConfig } from '../useConfig';
+import { act } from '@testing-library/react';
+
+describe('useGenerateCancelTransaction', () => {
+	const defaultArgs = {
+		chainId: '1',
+		orderId: '0x9876543210987654321098765432109876543210',
+		marketplace: MarketplaceKind.sequence_marketplace_v2,
+		collectionAddress: zeroAddress,
+		maker: '0x1234567890123456789012345678901234567890',
+	};
+
+	const mockConfig = {
+		projectAccessKey: 'test-key',
+		projectId: 'test-id',
+	};
+
+	beforeEach(() => {
+		// Reset handlers
+		server.resetHandlers();
+
+		// Mock useAccount to return an address
+		commonWagmiMocks.useAccount.mockReturnValue({
+			address: '0x1234567890123456789012345678901234567890',
+			isConnecting: false,
+			isDisconnected: false,
+			isReconnecting: false,
+			status: 'connected',
+		});
+
+		// Mock useConfig to return config
+		(useConfig as unknown as ReturnType<typeof vi.fn>).mockReturnValue(
+			mockConfig,
+		);
+
+		// Set up default success handler
+		server.use(
+			http.post(mockMarketplaceEndpoint('GenerateCancelTransaction'), () => {
+				return HttpResponse.json({ steps: mockSteps });
+			}),
+		);
+	});
+
+	it('should generate cancel transaction successfully', async () => {
+		const { result } = renderHook(() =>
+			useGenerateCancelTransaction(defaultArgs),
+		);
+
+		await act(async () => {
+			await result.current.generateCancelTransactionAsync(defaultArgs);
+		});
+
+		await waitFor(() => {
+			expect(result.current.data).toEqual(mockSteps);
+		});
+		expect(result.current.error).toBeNull();
+	});
+
+	it('should handle error states', async () => {
+		server.use(
+			http.post(mockMarketplaceEndpoint('GenerateCancelTransaction'), () => {
+				return HttpResponse.json(
+					{ error: { message: 'Failed to generate cancel transaction' } },
+					{ status: 500 },
+				);
+			}),
+		);
+
+		const { result } = renderHook(() =>
+			useGenerateCancelTransaction(defaultArgs),
+		);
+
+		await act(async () => {
+			try {
+				await result.current.generateCancelTransactionAsync(defaultArgs);
+			} catch (error) {
+				// Expected error
+			}
+		});
+
+		await waitFor(() => {
+			expect(result.current.isError).toBe(true);
+		});
+		expect(result.current.error).toBeDefined();
+	});
+
+	it('should not make request when wallet is not connected', async () => {
+		commonWagmiMocks.useAccount.mockReturnValue({
+			address: undefined,
+			isConnecting: false,
+			isDisconnected: true,
+			isReconnecting: false,
+			status: 'disconnected',
+		});
+
+		const { result } = renderHook(() =>
+			useGenerateCancelTransaction(defaultArgs),
+		);
+
+		expect(result.current.isPending).toBe(false);
+		expect(result.current.data).toBeUndefined();
+		expect(result.current.error).toBeNull();
+	});
+
+	it('should handle invalid order data', async () => {
+		const invalidArgs = {
+			...defaultArgs,
+			orderId: '', // Invalid order ID
+		};
+
+		server.use(
+			http.post(mockMarketplaceEndpoint('GenerateCancelTransaction'), () => {
+				return HttpResponse.json({ error: 'endpoint error' }, { status: 400 });
+			}),
+		);
+
+		const { result } = renderHook(() =>
+			useGenerateCancelTransaction(invalidArgs),
+		);
+
+		await act(async () => {
+			try {
+				await result.current.generateCancelTransactionAsync(invalidArgs);
+			} catch (error) {
+				// Expected error
+			}
+		});
+
+		await waitFor(() => {
+			expect(result.current.isError).toBe(true);
+		});
+		expect(result.current.error?.message).toBe('endpoint error');
+	});
+
+	it('should not make request when wallet is connecting', async () => {
+		commonWagmiMocks.useAccount.mockReturnValue({
+			address: undefined,
+			isConnecting: true,
+			isDisconnected: false,
+			isReconnecting: false,
+			status: 'connecting',
+		});
+
+		const { result } = renderHook(() =>
+			useGenerateCancelTransaction(defaultArgs),
+		);
+
+		expect(result.current.isPending).toBe(false);
+		expect(result.current.data).toBeUndefined();
+		expect(result.current.error).toBeNull();
+	});
+
+	it('should call onSuccess callback when provided', async () => {
+		const onSuccess = vi.fn();
+		const { result } = renderHook(() =>
+			useGenerateCancelTransaction({ ...defaultArgs, onSuccess }),
+		);
+
+		await act(async () => {
+			await result.current.generateCancelTransactionAsync(defaultArgs);
+		});
+
+		await waitFor(() => {
+			expect(onSuccess).toHaveBeenCalledWith(
+				[mockSteps[0]],
+				defaultArgs,
+				undefined,
+			);
+		});
+	});
+});

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

@@ -0,0 +1,207 @@
+import { describe, expect, it, vi, beforeEach } from 'vitest';
+import { useGenerateListingTransaction } from '../useGenerateListingTransaction';
+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 {
+	ContractType,
+	OrderbookKind,
+} from '../../_internal/api/marketplace.gen';
+import { useConfig } from '../useConfig';
+import type { SdkConfig } from '../../../types';
+import type { CreateReqWithDateExpiry } from '../useGenerateListingTransaction';
+
+// Mock useConfig hook
+vi.mock('../useConfig');
+
+describe('useGenerateListingTransaction', () => {
+	const mockOnSuccess = vi.fn();
+
+	const mockConfig: SdkConfig = {
+		projectId: 'test-project',
+		projectAccessKey: 'test-access-key',
+	};
+
+	const mockListing: CreateReqWithDateExpiry = {
+		tokenId: '1',
+		quantity: '1',
+		expiry: new Date('2024-12-31'),
+		currencyAddress: zeroAddress,
+		pricePerToken: '1000000000000000000',
+	};
+
+	const mockTransactionProps = {
+		collectionAddress: zeroAddress,
+		owner: zeroAddress,
+		contractType: ContractType.ERC721,
+		orderbook: OrderbookKind.sequence_marketplace_v2,
+		listing: mockListing,
+	};
+
+	const defaultArgs = {
+		chainId: '1' as const,
+		onSuccess: mockOnSuccess,
+	};
+
+	beforeEach(() => {
+		vi.clearAllMocks();
+
+		// Set up the mock implementation for useConfig
+		vi.mocked(useConfig).mockReturnValue(mockConfig);
+
+		// Mock default steps response
+		server.use(
+			http.post(mockMarketplaceEndpoint('GenerateListingTransaction'), () => {
+				return HttpResponse.json({
+					steps: mockSteps,
+				});
+			}),
+		);
+	});
+
+	it('should generate listing transaction successfully', async () => {
+		const { result } = renderHook(() =>
+			useGenerateListingTransaction(defaultArgs),
+		);
+
+		await result.current.generateListingTransactionAsync(mockTransactionProps);
+
+		expect(mockOnSuccess).toHaveBeenCalledWith(
+			mockSteps,
+			mockTransactionProps,
+			undefined,
+		);
+	});
+
+	it('should handle async generation with await', async () => {
+		const { result } = renderHook(() =>
+			useGenerateListingTransaction(defaultArgs),
+		);
+
+		const steps =
+			await result.current.generateListingTransactionAsync(
+				mockTransactionProps,
+			);
+
+		expect(steps).toEqual(mockSteps);
+	});
+
+	it('should handle non-async generation with callback', async () => {
+		const { result } = renderHook(() =>
+			useGenerateListingTransaction(defaultArgs),
+		);
+
+		result.current.generateListingTransaction(mockTransactionProps);
+
+		await waitFor(() => {
+			expect(mockOnSuccess).toHaveBeenCalledWith(
+				mockSteps,
+				mockTransactionProps,
+				undefined,
+			);
+		});
+	});
+
+	it('should handle API errors', async () => {
+		// Mock error response
+		server.use(
+			http.post(mockMarketplaceEndpoint('GenerateListingTransaction'), () => {
+				return new HttpResponse(null, { status: 500 });
+			}),
+		);
+
+		const { result } = renderHook(() =>
+			useGenerateListingTransaction(defaultArgs),
+		);
+
+		await expect(
+			result.current.generateListingTransactionAsync(mockTransactionProps),
+		).rejects.toThrow();
+
+		expect(mockOnSuccess).not.toHaveBeenCalled();
+	});
+
+	it('should convert Date expiry to Unix timestamp', async () => {
+		const expectedUnixTime = Math.floor(mockListing.expiry.getTime() / 1000);
+		// biome-ignore lint/suspicious/noExplicitAny: <explanation>
+		let requestBody: any;
+
+		server.use(
+			http.post(
+				mockMarketplaceEndpoint('GenerateListingTransaction'),
+				async ({ request }) => {
+					requestBody = await request.json();
+					return HttpResponse.json({ steps: mockSteps });
+				},
+			),
+		);
+
+		const { result } = renderHook(() =>
+			useGenerateListingTransaction(defaultArgs),
+		);
+		await result.current.generateListingTransactionAsync(mockTransactionProps);
+
+		expect(Number(requestBody.listing.expiry)).toBe(expectedUnixTime);
+	});
+
+	it('should use provided config from useConfig hook', async () => {
+		const customConfig: SdkConfig = {
+			projectId: 'custom-project',
+			projectAccessKey: 'custom-access-key',
+		};
+
+		let requestHeaders: Headers | undefined;
+
+		server.use(
+			http.post(
+				mockMarketplaceEndpoint('GenerateListingTransaction'),
+				async ({ request }) => {
+					requestHeaders = request.headers;
+					return HttpResponse.json({ steps: mockSteps });
+				},
+			),
+		);
+
+		vi.mocked(useConfig).mockReturnValue(customConfig);
+
+		const { result } = renderHook(() =>
+			useGenerateListingTransaction(defaultArgs),
+		);
+		await result.current.generateListingTransactionAsync(mockTransactionProps);
+
+		expect(requestHeaders?.get('x-access-key')).toBe(
+			customConfig.projectAccessKey,
+		);
+	});
+
+	it('should handle invalid listing data', async () => {
+		const invalidListing = {
+			...mockListing,
+			pricePerToken: 'invalid-price',
+		};
+
+		server.use(
+			http.post(mockMarketplaceEndpoint('GenerateListingTransaction'), () => {
+				return new HttpResponse(null, { status: 400 });
+			}),
+		);
+
+		const { result } = renderHook(() =>
+			useGenerateListingTransaction(defaultArgs),
+		);
+
+		await expect(
+			result.current.generateListingTransactionAsync({
+				...mockTransactionProps,
+				listing: invalidListing,
+			}),
+		).rejects.toThrow();
+
+		expect(mockOnSuccess).not.toHaveBeenCalled();
+	});
+});

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

@@ -0,0 +1,205 @@
+import { describe, expect, it, vi, beforeEach } from 'vitest';
+import { useGenerateOfferTransaction } from '../useGenerateOfferTransaction';
+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 {
+	ContractType,
+	OrderbookKind,
+} from '../../_internal/api/marketplace.gen';
+import { useConfig } from '../useConfig';
+import type { SdkConfig } from '../../../types';
+
+// Mock useConfig hook
+vi.mock('../useConfig');
+
+describe('useGenerateOfferTransaction', () => {
+	const mockOnSuccess = vi.fn();
+
+	const mockConfig: SdkConfig = {
+		projectId: 'test-project',
+		projectAccessKey: 'test-access-key',
+	};
+
+	const mockOffer = {
+		tokenId: '1',
+		quantity: '1',
+		expiry: new Date('2024-12-31'),
+		currencyAddress: zeroAddress,
+		pricePerToken: '1000000000000000000',
+	};
+
+	const mockTransactionProps = {
+		collectionAddress: zeroAddress,
+		maker: zeroAddress,
+		contractType: ContractType.ERC721,
+		orderbook: OrderbookKind.sequence_marketplace_v2,
+		offer: mockOffer,
+	};
+
+	const defaultArgs = {
+		chainId: '1' as const,
+		onSuccess: mockOnSuccess,
+	};
+
+	beforeEach(() => {
+		vi.clearAllMocks();
+
+		// Set up the mock implementation for useConfig
+		vi.mocked(useConfig).mockReturnValue(mockConfig);
+
+		// Mock default steps response
+		server.use(
+			http.post(mockMarketplaceEndpoint('GenerateOfferTransaction'), () => {
+				return HttpResponse.json({
+					steps: mockSteps,
+				});
+			}),
+		);
+	});
+
+	it('should generate offer transaction successfully', async () => {
+		const { result } = renderHook(() =>
+			useGenerateOfferTransaction(defaultArgs),
+		);
+
+		await result.current.generateOfferTransactionAsync(mockTransactionProps);
+
+		expect(mockOnSuccess).toHaveBeenCalledWith(
+			mockSteps,
+			mockTransactionProps,
+			undefined,
+		);
+	});
+
+	it('should handle async generation with await', async () => {
+		const { result } = renderHook(() =>
+			useGenerateOfferTransaction(defaultArgs),
+		);
+
+		const steps =
+			await result.current.generateOfferTransactionAsync(mockTransactionProps);
+
+		expect(steps).toEqual(mockSteps);
+	});
+
+	it('should handle non-async generation with callback', async () => {
+		const { result } = renderHook(() =>
+			useGenerateOfferTransaction(defaultArgs),
+		);
+
+		result.current.generateOfferTransaction(mockTransactionProps);
+
+		await waitFor(() => {
+			expect(mockOnSuccess).toHaveBeenCalledWith(
+				mockSteps,
+				mockTransactionProps,
+				undefined,
+			);
+		});
+	});
+
+	it('should handle API errors', async () => {
+		// Mock error response
+		server.use(
+			http.post(mockMarketplaceEndpoint('GenerateOfferTransaction'), () => {
+				return new HttpResponse(null, { status: 500 });
+			}),
+		);
+
+		const { result } = renderHook(() =>
+			useGenerateOfferTransaction(defaultArgs),
+		);
+
+		await expect(
+			result.current.generateOfferTransactionAsync(mockTransactionProps),
+		).rejects.toThrow();
+
+		expect(mockOnSuccess).not.toHaveBeenCalled();
+	});
+
+	it('should convert Date expiry to Unix timestamp', async () => {
+		const expectedUnixTime = Math.floor(mockOffer.expiry.getTime() / 1000);
+
+		// biome-ignore lint/suspicious/noExplicitAny: <explanation>
+		let requestBody: any;
+
+		server.use(
+			http.post(
+				mockMarketplaceEndpoint('GenerateOfferTransaction'),
+				async ({ request }) => {
+					requestBody = await request.json();
+					return HttpResponse.json({ steps: mockSteps });
+				},
+			),
+		);
+
+		const { result } = renderHook(() =>
+			useGenerateOfferTransaction(defaultArgs),
+		);
+		await result.current.generateOfferTransactionAsync(mockTransactionProps);
+
+		expect(Number(requestBody.offer.expiry)).toBe(expectedUnixTime);
+	});
+
+	it('should use provided config from useConfig hook', async () => {
+		const customConfig: SdkConfig = {
+			projectId: 'custom-project',
+			projectAccessKey: 'custom-access-key',
+		};
+
+		let requestHeaders: Headers | undefined;
+
+		server.use(
+			http.post(
+				mockMarketplaceEndpoint('GenerateOfferTransaction'),
+				async ({ request }) => {
+					requestHeaders = request.headers;
+					return HttpResponse.json({ steps: mockSteps });
+				},
+			),
+		);
+
+		vi.mocked(useConfig).mockReturnValue(customConfig);
+
+		const { result } = renderHook(() =>
+			useGenerateOfferTransaction(defaultArgs),
+		);
+		await result.current.generateOfferTransactionAsync(mockTransactionProps);
+
+		expect(requestHeaders?.get('x-access-key')).toBe(
+			customConfig.projectAccessKey,
+		);
+	});
+
+	it('should handle invalid offer data', async () => {
+		const invalidOffer = {
+			...mockOffer,
+			pricePerToken: 'invalid-price',
+		};
+
+		server.use(
+			http.post(mockMarketplaceEndpoint('GenerateOfferTransaction'), () => {
+				return new HttpResponse(null, { status: 400 });
+			}),
+		);
+
+		const { result } = renderHook(() =>
+			useGenerateOfferTransaction(defaultArgs),
+		);
+
+		await expect(
+			result.current.generateOfferTransactionAsync({
+				...mockTransactionProps,
+				offer: invalidOffer,
+			}),
+		).rejects.toThrow();
+
+		expect(mockOnSuccess).not.toHaveBeenCalled();
+	});
+});