@0xsequence/marketplace-sdk 0.7.0 → 0.8.0

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

@@ -1,172 +0,0 @@
-import { renderHook, server } from '@test';
-import { http, HttpResponse } from 'msw';
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-import { mock, useAccount, useConnect, useDisconnect } from 'wagmi';
-import { MarketplaceKind, WalletKind } from '../../_internal';
-import {
-	mockMarketplaceEndpoint,
-	mockSteps,
-} from '../../_internal/api/__mocks__/marketplace.msw';
-import { useGenerateBuyTransaction } from '../useGenerateBuyTransaction';
-
-describe('useGenerateBuyTransaction', () => {
-	const defaultArgs = {
-		chainId: '1',
-		collectionAddress:
-			'0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266' as `0x${string}`,
-		marketplace: MarketplaceKind.sequence_marketplace_v2,
-		ordersData: [
-			{
-				marketplace: MarketplaceKind.sequence_marketplace_v2,
-				orderId: '1',
-				quantity: '1',
-				price: '1',
-				currency: 'ETH',
-				currencyAddress:
-					'0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266' as `0x${string}`,
-				currencyDecimals: 18,
-				currencySymbol: 'ETH',
-				currencyName: 'Ether',
-			},
-		],
-		walletType: WalletKind.sequence,
-		query: {},
-	};
-
-	beforeEach(() => {
-		vi.clearAllMocks();
-
-		// Mock default steps response with delay to simulate loading state
-		server.use(
-			http.post(mockMarketplaceEndpoint('GenerateBuyTransaction'), async () => {
-				await new Promise((resolve) => setTimeout(resolve, 100)); // Add small delay
-				return HttpResponse.json({
-					steps: mockSteps,
-				});
-			}),
-		);
-	});
-
-	it('should skip query when no address is available', async () => {
-		const { result: generateBuyTransactionResult } = renderHook(() =>
-			useGenerateBuyTransaction(defaultArgs),
-		);
-		const { result: disconnectResult } = renderHook(() => useDisconnect());
-
-		// make sure we are disconnected
-		await disconnectResult.current.disconnectAsync();
-
-		expect(generateBuyTransactionResult.current.isLoading).toBe(false);
-		expect(generateBuyTransactionResult.current.error).toBeNull();
-		expect(generateBuyTransactionResult.current.data).toBeUndefined();
-	});
-
-	it('should fetch transaction data when wallet is connected', async () => {
-		// Setup mock wallet connection
-		const mockAddress = '0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266';
-		const { result: accountResult } = renderHook(() => useAccount());
-		const { result: connectResult } = renderHook(() => useConnect());
-
-		await connectResult.current.connectAsync({
-			connector: mock({
-				accounts: [mockAddress],
-			}),
-		});
-
-		// Ensure we have a connected wallet
-		expect(accountResult.current.address).toBe(mockAddress);
-
-		const { result } = renderHook(() => useGenerateBuyTransaction(defaultArgs));
-
-		// Initial state should be loading
-		expect(result.current.isLoading).toBe(true);
-		expect(result.current.data).toBeUndefined();
-
-		// Wait for the query to complete
-		await vi.waitFor(() => {
-			expect(result.current.isLoading).toBe(false);
-		});
-
-		// Verify the data matches our mock
-		expect(result.current.error).toBeNull();
-		expect(result.current.data).toEqual(mockSteps);
-	});
-
-	it('should handle API errors correctly', async () => {
-		// Setup mock wallet connection
-		const mockAddress = '0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266';
-		const { result: connectResult } = renderHook(() => useConnect());
-
-		await connectResult.current.connectAsync({
-			connector: mock({
-				accounts: [mockAddress],
-			}),
-		});
-
-		// Mock API error response
-		server.use(
-			http.post(mockMarketplaceEndpoint('GenerateBuyTransaction'), () => {
-				return HttpResponse.json(
-					{ message: 'Invalid order data' },
-					{ status: 400 },
-				);
-			}),
-		);
-
-		const { result } = renderHook(() => useGenerateBuyTransaction(defaultArgs));
-
-		// Initial state should be loading
-		expect(result.current.isLoading).toBe(true);
-		expect(result.current.error).toBeNull();
-		expect(result.current.data).toBeUndefined();
-
-		// Wait for the query to complete
-		await vi.waitFor(() => {
-			expect(result.current.isLoading).toBe(false);
-		});
-
-		// Verify error state
-		expect(result.current.error).toBeTruthy();
-		expect(result.current.data).toBeUndefined();
-	});
-
-	it('should handle invalid input arguments correctly', async () => {
-		// Setup mock wallet connection
-		const mockAddress = '0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266';
-		const { result: connectResult } = renderHook(() => useConnect());
-
-		await connectResult.current.connectAsync({
-			connector: mock({
-				accounts: [mockAddress],
-			}),
-		});
-
-		// Create invalid args by omitting required fields and using invalid types
-		const invalidArgs = {
-			...defaultArgs,
-			chainId: 1, // Should be string
-			collectionAddress: 'invalid-address', // Invalid address format
-			ordersData: [
-				{
-					...defaultArgs.ordersData[0],
-					quantity: 1, // Should be string
-					orderId: undefined, // Required field missing
-				},
-			],
-		};
-
-		const { result } = renderHook(() =>
-			// @ts-expect-error - Testing runtime validation
-			useGenerateBuyTransaction(invalidArgs),
-		);
-
-		// Wait for the query to complete
-		await vi.waitFor(() => {
-			expect(result.current.isLoading).toBe(false);
-		});
-
-		// Verify validation error state
-		expect(result.current.error).toBeTruthy();
-		expect(result.current.data).toBeUndefined();
-	});
-});

package/src/react/hooks/useGenerateBuyTransaction.tsx

@@ -1,80 +0,0 @@
-import { queryOptions, skipToken, useQuery } from '@tanstack/react-query';
-import type { Hex } from 'viem';
-import { useAccount } from 'wagmi';
-import { z } from 'zod';
-import type { SdkConfig } from '../../types';
-import {
-	AddressSchema,
-	ChainIdSchema,
-	MarketplaceKind,
-	QueryArgSchema,
-	WalletKind,
-	getMarketplaceClient,
-} from '../_internal';
-import { useConfig } from './useConfig';
-
-export const UseGenerateBuyTransactionArgsSchema = z.object({
-	chainId: ChainIdSchema.pipe(z.coerce.string()),
-	collectionAddress: AddressSchema,
-	marketplace: z.nativeEnum(MarketplaceKind),
-	ordersData: z.array(
-		z.object({
-			orderId: z.string(),
-			quantity: z.string(),
-			marketplace: z.string(),
-			tokenId: z.string().optional(),
-		}),
-	),
-	walletType: z.nativeEnum(WalletKind).optional(),
-	query: QueryArgSchema,
-});
-
-type UseGenerateBuyTransactionArgs = z.infer<
-	typeof UseGenerateBuyTransactionArgsSchema
->;
-
-export const fetchGenerateBuyTransaction = async (
-	args: UseGenerateBuyTransactionArgs & { buyer: Hex },
-	config: SdkConfig,
-) => {
-	const parsedArgs = UseGenerateBuyTransactionArgsSchema.parse(args);
-	const marketplaceClient = getMarketplaceClient(parsedArgs.chainId, config);
-
-	return marketplaceClient
-		.generateBuyTransaction({
-			...parsedArgs,
-			buyer: args.buyer,
-			additionalFees: [], // TODO: Add additional fees
-		})
-		.then((data) => data.steps);
-};
-
-export const generateBuyTransactionOptions = (
-	args: UseGenerateBuyTransactionArgs & { buyer: Hex },
-	config: SdkConfig,
-) => {
-	return queryOptions({
-		queryKey: ['generateBuyTransaction', args],
-		queryFn: () => fetchGenerateBuyTransaction(args, config),
-		...args.query,
-	});
-};
-
-export const useGenerateBuyTransaction = (
-	args: UseGenerateBuyTransactionArgs,
-) => {
-	const { address } = useAccount();
-	const config = useConfig();
-
-	return useQuery({
-		queryKey: ['generateBuyTransaction', args],
-		queryFn: address
-			? () => {
-					return fetchGenerateBuyTransaction(
-						{ buyer: address, ...args },
-						config,
-					);
-				}
-			: skipToken,
-	});
-};

package/src/react/ui/modals/BuyModal/hooks/__tests__/useBuyCollectable.test.tsx

@@ -1,349 +0,0 @@
-import { useSelectPaymentModal } from '@0xsequence/checkout';
-import { renderHook } from '@testing-library/react';
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-
-import {
-	MarketplaceKind,
-	WalletKind,
-} from '../../../../../_internal/api/marketplace.gen';
-import { TransactionCrypto } from '../../../../../_internal/api/marketplace.gen';
-import { getMarketplaceClient } from '../../../../../_internal/api/services';
-import { useWallet } from '../../../../../_internal/wallet/useWallet';
-import { useConfig } from '../../../../../hooks';
-import { useBuyCollectable } from '../useBuyCollectable';
-import { useFees } from '../useFees';
-
-// Mock dependencies
-vi.mock('@0xsequence/checkout', () => ({
-	useSelectPaymentModal: vi.fn(),
-}));
-
-vi.mock('../../../../../_internal/wallet/useWallet', () => ({
-	useWallet: vi.fn(),
-}));
-
-vi.mock('../../../../../hooks', () => ({
-	useConfig: vi.fn(),
-}));
-
-vi.mock('../useFees', () => ({
-	useFees: vi.fn(),
-}));
-
-vi.mock('../../../../../_internal', (actualImport) => {
-	const actualModule = actualImport();
-	return {
-		getMarketplaceClient: vi.fn(),
-		...actualModule,
-	};
-});
-
-describe('useBuyCollectable', () => {
-	const defaultProps = {
-		chainId: '1',
-		collectionAddress: '0x123',
-		tokenId: '1',
-		priceCurrencyAddress: '0x0',
-		setCheckoutModalIsLoading: vi.fn(),
-		setCheckoutModalLoaded: vi.fn(),
-	};
-
-	beforeEach(() => {
-		vi.clearAllMocks();
-
-		// Setup default mock implementations
-		(
-			useSelectPaymentModal as unknown as ReturnType<typeof vi.fn>
-		).mockReturnValue({
-			openSelectPaymentModal: vi.fn(),
-		});
-
-		(useConfig as unknown as ReturnType<typeof vi.fn>).mockReturnValue({
-			projectAccessKey: 'test-key',
-			projectId: 'test-id',
-		});
-
-		(useFees as unknown as ReturnType<typeof vi.fn>).mockReturnValue({
-			amount: '250',
-			receiver: '0x123',
-		});
-	});
-
-	it('should return loading state initially', () => {
-		// Mock useWallet to return loading state
-		(useWallet as unknown as ReturnType<typeof vi.fn>).mockReturnValue({
-			wallet: null,
-			isLoading: true,
-			isError: false,
-		});
-
-		const { result } = renderHook(() => useBuyCollectable(defaultProps));
-
-		expect(result.current).toEqual({
-			status: 'loading',
-			buy: null,
-			isLoading: true,
-			isError: false,
-		});
-	});
-
-	it('should return error state when wallet is not available', () => {
-		// Mock useWallet to return error state
-		(useWallet as unknown as ReturnType<typeof vi.fn>).mockReturnValue({
-			wallet: null,
-			isLoading: false,
-			isError: true,
-		});
-
-		const { result } = renderHook(() => useBuyCollectable(defaultProps));
-
-		expect(result.current).toEqual({
-			status: 'error',
-			buy: null,
-			isLoading: false,
-			isError: true,
-		});
-
-		// Also test when wallet is undefined but no error
-		(useWallet as unknown as ReturnType<typeof vi.fn>).mockReturnValue({
-			wallet: undefined,
-			isLoading: false,
-			isError: false,
-		});
-
-		const { result: result2 } = renderHook(() =>
-			useBuyCollectable(defaultProps),
-		);
-
-		expect(result2.current).toEqual({
-			status: 'error',
-			buy: null,
-			isLoading: false,
-			isError: true,
-		});
-	});
-
-	it.skip('should call buy function with correct parameters', async () => {
-		// Mock useWallet to return a valid wallet
-		(useWallet as unknown as ReturnType<typeof vi.fn>).mockReturnValue({
-			wallet: {
-				kind: WalletKind.sequence,
-				address: async () => '0x123',
-				chainId: '1',
-			},
-			isLoading: false,
-			isError: false,
-		});
-
-		const openSelectPaymentModalMock = vi.fn();
-		(
-			useSelectPaymentModal as unknown as ReturnType<typeof vi.fn>
-		).mockReturnValue({
-			openSelectPaymentModal: openSelectPaymentModalMock,
-		});
-
-		const generateBuyTransactionMock = vi.fn().mockResolvedValue({
-			steps: [
-				{
-					type: 'transaction',
-					value: '1000000000000000000',
-					to: '0x123',
-					data: '0x456',
-				},
-			],
-		});
-
-		const marketplaceClientMock = {
-			generateBuyTransaction: generateBuyTransactionMock,
-		};
-
-		(
-			getMarketplaceClient as unknown as ReturnType<typeof vi.fn>
-		).mockReturnValue(marketplaceClientMock);
-
-		const { result } = renderHook(() => useBuyCollectable(defaultProps));
-
-		if (result.current.status === 'ready') {
-			await result.current.buy({
-				orderId: '1',
-				quantity: '1',
-				collectableDecimals: 18,
-				marketplace: MarketplaceKind.sequence_marketplace_v2,
-				checkoutOptions: {
-					swap: [],
-					nftCheckout: [],
-					onRamp: [],
-					crypto: TransactionCrypto.all,
-				},
-			});
-		}
-
-		expect(generateBuyTransactionMock).toHaveBeenCalledWith({
-			collectionAddress: defaultProps.collectionAddress,
-			buyer: '0x123',
-			marketplace: MarketplaceKind.sequence_marketplace_v2,
-			ordersData: [
-				{
-					orderId: '1',
-					quantity: '1',
-				},
-			],
-			additionalFees: [
-				{
-					amount: '250',
-					receiver: '0x123',
-				},
-			],
-			walletType: WalletKind.unknown,
-		});
-
-		expect(openSelectPaymentModalMock).toHaveBeenCalledWith({
-			chain: defaultProps.chainId,
-			collectibles: [
-				{
-					tokenId: defaultProps.tokenId,
-					quantity: '1',
-					decimals: 18,
-				},
-			],
-			currencyAddress: defaultProps.priceCurrencyAddress,
-			price: '1000000000000000000',
-			targetContractAddress: '0x123',
-			txData: '0x456',
-			collectionAddress: defaultProps.collectionAddress,
-			recipientAddress: '0x123',
-			enableMainCurrencyPayment: true,
-			enableSwapPayments: true,
-			creditCardProviders: [],
-			onSuccess: expect.any(Function),
-			onError: undefined,
-			onClose: expect.any(Function),
-		});
-
-		expect(defaultProps.setCheckoutModalIsLoading).toHaveBeenCalledWith(true);
-		expect(defaultProps.setCheckoutModalLoaded).toHaveBeenCalledWith(true);
-	});
-
-	it.skip('should handle success callback', async () => {
-		(useWallet as unknown as ReturnType<typeof vi.fn>).mockReturnValue({
-			wallet: {
-				kind: WalletKind.sequence,
-				address: async () => '0x123',
-				chainId: '1',
-			},
-			isLoading: false,
-			isError: false,
-		});
-
-		const openSelectPaymentModalMock = vi.fn();
-		(
-			useSelectPaymentModal as unknown as ReturnType<typeof vi.fn>
-		).mockReturnValue({
-			openSelectPaymentModal: openSelectPaymentModalMock,
-		});
-
-		// const generateBuyTransactionMock = vi.fn().mockResolvedValue({
-		// 	steps: [
-		// 		{
-		// 			type: 'transaction',
-		// 			value: '1000000000000000000',
-		// 			to: '0x123',
-		// 			data: '0x456',
-		// 		},
-		// 	],
-		// });
-
-		// const marketplaceClientMock = {
-		// 	generateBuyTransaction: generateBuyTransactionMock,
-		// };
-
-		// (
-		// 	getMarketplaceClient as unknown as ReturnType<typeof vi.fn>
-		// ).mockReturnValue(marketplaceClientMock);
-
-		const onSuccessMock = vi.fn();
-		const props = {
-			...defaultProps,
-			callbacks: {
-				onSuccess: onSuccessMock,
-			},
-		};
-
-		const { result } = renderHook(() => useBuyCollectable(props));
-
-		if (result.current.status === 'ready') {
-			await result.current.buy({
-				orderId: '1',
-				quantity: '1',
-				collectableDecimals: 18,
-				marketplace: MarketplaceKind.sequence_marketplace_v2,
-				checkoutOptions: {
-					swap: [],
-					nftCheckout: [],
-					onRamp: [],
-					crypto: TransactionCrypto.all,
-				},
-			});
-		}
-
-		const onSuccessCallback =
-			openSelectPaymentModalMock.mock.calls[0][0].onSuccess;
-
-		const txHash = '0x789';
-		await onSuccessCallback(txHash);
-
-		expect(onSuccessMock).toHaveBeenCalledWith({ hash: txHash });
-	});
-
-	it.skip('should handle error callback', async () => {
-		// Mock useWallet to return a valid wallet
-		(useWallet as unknown as ReturnType<typeof vi.fn>).mockReturnValue({
-			wallet: {
-				kind: WalletKind.sequence,
-				address: async () => '0x123',
-				chainId: '1',
-			},
-			isLoading: false,
-			isError: false,
-		});
-
-		const openSelectPaymentModalMock = vi.fn();
-		(
-			useSelectPaymentModal as unknown as ReturnType<typeof vi.fn>
-		).mockReturnValue({
-			openSelectPaymentModal: openSelectPaymentModalMock,
-		});
-
-		const onErrorMock = vi.fn();
-		const props = {
-			...defaultProps,
-			callbacks: {
-				onError: onErrorMock,
-			},
-		};
-
-		const { result } = renderHook(() => useBuyCollectable(props));
-
-		if (result.current.status === 'ready') {
-			await result.current.buy({
-				orderId: '1',
-				quantity: '1',
-				collectableDecimals: 18,
-				marketplace: MarketplaceKind.sequence_marketplace_v2,
-				checkoutOptions: {
-					swap: [],
-					nftCheckout: [],
-					onRamp: [],
-					crypto: TransactionCrypto.all,
-				},
-			});
-		}
-
-		const onErrorCallback = openSelectPaymentModalMock.mock.calls[0][0].onError;
-
-		const error = new Error('Transaction failed');
-		onErrorCallback(error);
-
-		expect(onErrorMock).toHaveBeenCalledWith(error);
-	});
-});