@0xsequence/marketplace-sdk 0.8.11 → 0.9.0

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

@@ -0,0 +1,379 @@
+import { renderHook } from '@test';
+import type { Address } from 'viem';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import {
+	type CheckoutOptions,
+	TransactionCrypto,
+} from '../../../../../_internal';
+import { useERC1155Checkout } from '../useERC1155Checkout';
+
+// Mock @0xsequence/checkout
+vi.mock('@0xsequence/checkout', () => ({
+	useERC1155SaleContractCheckout: vi.fn(() => ({
+		openCheckoutModal: vi.fn(),
+		isLoading: false,
+		isError: false,
+	})),
+}));
+
+// Mock wagmi's useAccount hook
+vi.mock('wagmi', async () => {
+	const actual = await vi.importActual('wagmi');
+	return {
+		...actual,
+		useAccount: vi.fn(() => ({
+			address: '0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266' as Address,
+		})),
+	};
+});
+
+// Mock store hooks
+vi.mock('../../store', () => ({
+	useQuantity: vi.fn(() => 2),
+	useOnSuccess: vi.fn(() => vi.fn()),
+	useOnError: vi.fn(() => vi.fn()),
+	buyModalStore: {
+		send: vi.fn(),
+	},
+}));
+
+const mockCheckoutOptions = {
+	crypto: TransactionCrypto.all,
+	swap: [],
+	nftCheckout: [],
+	onRamp: [],
+} satisfies CheckoutOptions;
+
+const mockItems = [
+	{ tokenId: '1', quantity: '2' },
+	{ tokenId: '2', quantity: '1' },
+];
+
+describe('useERC1155Checkout', () => {
+	let mockUseERC1155SaleContractCheckout: ReturnType<typeof vi.fn>;
+
+	beforeEach(async () => {
+		vi.clearAllMocks();
+
+		// Setup the mock for useERC1155SaleContractCheckout
+		mockUseERC1155SaleContractCheckout = vi.mocked(
+			(await import('@0xsequence/checkout')).useERC1155SaleContractCheckout,
+		);
+	});
+
+	afterEach(() => {
+		vi.restoreAllMocks();
+	});
+
+	it('should call useERC1155SaleContractCheckout with correct parameters', () => {
+		const mockCheckout = {
+			openCheckoutModal: vi.fn(),
+			isLoading: false,
+			isError: false,
+		};
+		mockUseERC1155SaleContractCheckout.mockReturnValue(mockCheckout);
+
+		const { result } = renderHook(() =>
+			useERC1155Checkout({
+				chainId: 1,
+				salesContractAddress: '0x456',
+				collectionAddress: '0x123',
+				items: mockItems,
+				checkoutOptions: mockCheckoutOptions,
+				enabled: true,
+			}),
+		);
+
+		expect(
+			mockUseERC1155SaleContractCheckout.mock.calls,
+		).toMatchInlineSnapshot(`
+      [
+        [
+          {
+            "chain": 1,
+            "checkoutOptions": {
+              "crypto": "all",
+              "nftCheckout": [],
+              "onRamp": [],
+              "swap": [],
+            },
+            "collectionAddress": "0x123",
+            "contractAddress": "0x456",
+            "customProviderCallback": undefined,
+            "items": [
+              {
+                "quantity": "2",
+                "tokenId": "1",
+              },
+            ],
+            "onClose": [Function],
+            "onError": [Function],
+            "onSuccess": [Function],
+            "supplementaryAnalyticsInfo": {
+              "type": "mint_shop",
+            },
+            "wallet": "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266",
+          },
+        ],
+      ]
+    `);
+
+		expect(result.current.isEnabled).toBe(true);
+	});
+
+	it('should return isEnabled false when no wallet is connected', async () => {
+		const { useAccount } = vi.mocked(await import('wagmi'));
+		useAccount.mockReturnValue({
+			address: undefined,
+			isConnected: false,
+			isConnecting: false,
+			isDisconnected: true,
+			isReconnecting: false,
+			connector: null,
+			addresses: undefined,
+			chain: undefined,
+			chainId: undefined,
+			status: 'disconnected',
+		} as never);
+
+		const mockCheckout = {
+			openCheckoutModal: vi.fn(),
+			isLoading: false,
+			isError: false,
+		};
+		mockUseERC1155SaleContractCheckout.mockReturnValue(mockCheckout);
+
+		const { result } = renderHook(() =>
+			useERC1155Checkout({
+				chainId: 1,
+				salesContractAddress: '0x456',
+				collectionAddress: '0x123',
+				items: mockItems,
+				enabled: true,
+			}),
+		);
+
+		expect(result.current.isEnabled).toBe(false);
+	});
+
+	it('should return isEnabled false when explicitly disabled', () => {
+		const mockCheckout = {
+			openCheckoutModal: vi.fn(),
+			isLoading: false,
+			isError: false,
+		};
+		mockUseERC1155SaleContractCheckout.mockReturnValue(mockCheckout);
+
+		const { result } = renderHook(() =>
+			useERC1155Checkout({
+				chainId: 1,
+				salesContractAddress: '0x456',
+				collectionAddress: '0x123',
+				items: mockItems,
+				enabled: false,
+			}),
+		);
+
+		expect(result.current.isEnabled).toBe(false);
+	});
+
+	it('should handle custom provider callback', () => {
+		const customCallback = vi.fn();
+		const mockCheckout = {
+			openCheckoutModal: vi.fn(),
+			isLoading: false,
+			isError: false,
+		};
+		mockUseERC1155SaleContractCheckout.mockReturnValue(mockCheckout);
+
+		renderHook(() =>
+			useERC1155Checkout({
+				chainId: 1,
+				salesContractAddress: '0x456',
+				collectionAddress: '0x123',
+				items: mockItems,
+				customProviderCallback: customCallback,
+				enabled: true,
+			}),
+		);
+
+		expect(mockUseERC1155SaleContractCheckout).toHaveBeenCalledWith(
+			expect.objectContaining({
+				customProviderCallback: customCallback,
+			}),
+		);
+	});
+
+	it('should use default quantity of 1 when quantity store returns null', async () => {
+		const storeModule = await import('../../store');
+		const useQuantitySpy = vi.spyOn(storeModule, 'useQuantity');
+		useQuantitySpy.mockReturnValue(null);
+
+		const mockCheckout = {
+			openCheckoutModal: vi.fn(),
+			isLoading: false,
+			isError: false,
+		};
+		mockUseERC1155SaleContractCheckout.mockReturnValue(mockCheckout);
+
+		renderHook(() =>
+			useERC1155Checkout({
+				chainId: 1,
+				salesContractAddress: '0x456',
+				collectionAddress: '0x123',
+				items: mockItems,
+				enabled: true,
+			}),
+		);
+
+		expect(mockUseERC1155SaleContractCheckout).toHaveBeenCalledWith(
+			expect.objectContaining({
+				items: [
+					{
+						tokenId: '1',
+						quantity: '1', // Default value
+					},
+				],
+			}),
+		);
+
+		useQuantitySpy.mockRestore();
+	});
+
+	it('should handle different chain IDs', () => {
+		const mockCheckout = {
+			openCheckoutModal: vi.fn(),
+			isLoading: false,
+			isError: false,
+		};
+		mockUseERC1155SaleContractCheckout.mockReturnValue(mockCheckout);
+
+		renderHook(() =>
+			useERC1155Checkout({
+				chainId: 137, // Polygon
+				salesContractAddress: '0x456',
+				collectionAddress: '0x123',
+				items: mockItems,
+				enabled: true,
+			}),
+		);
+
+		expect(mockUseERC1155SaleContractCheckout).toHaveBeenCalledWith(
+			expect.objectContaining({
+				chain: 137,
+			}),
+		);
+	});
+
+	it('should omit checkoutOptions when not provided', () => {
+		const mockCheckout = {
+			openCheckoutModal: vi.fn(),
+			isLoading: false,
+			isError: false,
+		};
+		mockUseERC1155SaleContractCheckout.mockReturnValue(mockCheckout);
+
+		renderHook(() =>
+			useERC1155Checkout({
+				chainId: 1,
+				salesContractAddress: '0x456',
+				collectionAddress: '0x123',
+				items: mockItems,
+				enabled: true,
+			}),
+		);
+
+		const callArgs = mockUseERC1155SaleContractCheckout.mock.calls[0][0];
+		expect(callArgs).not.toHaveProperty('checkoutOptions');
+	});
+
+	it('should spread all properties from useERC1155SaleContractCheckout', () => {
+		const mockCheckout = {
+			openCheckoutModal: vi.fn(),
+			isLoading: false,
+			isError: false,
+			additionalProp: 'test',
+		};
+		mockUseERC1155SaleContractCheckout.mockReturnValue(mockCheckout);
+
+		const { result } = renderHook(() =>
+			useERC1155Checkout({
+				chainId: 1,
+				salesContractAddress: '0x456',
+				collectionAddress: '0x123',
+				items: mockItems,
+				enabled: true,
+			}),
+		);
+
+		expect(result.current.openCheckoutModal).toBe(
+			mockCheckout.openCheckoutModal,
+		);
+		expect(result.current.isLoading).toBe(mockCheckout.isLoading);
+		expect(result.current.isError).toBe(mockCheckout.isError);
+	});
+
+	it('should include callback functions in checkout params', () => {
+		const mockCheckout = {
+			openCheckoutModal: vi.fn(),
+			isLoading: false,
+			isError: false,
+		};
+		mockUseERC1155SaleContractCheckout.mockReturnValue(mockCheckout);
+
+		renderHook(() =>
+			useERC1155Checkout({
+				chainId: 1,
+				salesContractAddress: '0x456',
+				collectionAddress: '0x123',
+				items: mockItems,
+				enabled: true,
+			}),
+		);
+
+		const callArgs = mockUseERC1155SaleContractCheckout.mock.calls[0][0];
+
+		expect(callArgs.onSuccess).toBeInstanceOf(Function);
+		expect(callArgs.onError).toBeInstanceOf(Function);
+		expect(callArgs.onClose).toBeInstanceOf(Function);
+	});
+
+	it('should use empty wallet string when address is undefined', async () => {
+		const { useAccount } = vi.mocked(await import('wagmi'));
+		useAccount.mockReturnValue({
+			address: undefined,
+			isConnected: false,
+			isConnecting: false,
+			isDisconnected: true,
+			isReconnecting: false,
+			connector: null,
+			addresses: undefined,
+			chain: undefined,
+			chainId: undefined,
+			status: 'disconnected',
+		} as never);
+
+		const mockCheckout = {
+			openCheckoutModal: vi.fn(),
+			isLoading: false,
+			isError: false,
+		};
+		mockUseERC1155SaleContractCheckout.mockReturnValue(mockCheckout);
+
+		renderHook(() =>
+			useERC1155Checkout({
+				chainId: 1,
+				salesContractAddress: '0x456',
+				collectionAddress: '0x123',
+				items: mockItems,
+				enabled: true,
+			}),
+		);
+
+		expect(mockUseERC1155SaleContractCheckout).toHaveBeenCalledWith(
+			expect.objectContaining({
+				wallet: '',
+			}),
+		);
+	});
+});

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

@@ -0,0 +1,253 @@
+import { renderHook } from '@test';
+import type { Address } from 'viem';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import {
+	getERC721SalePaymentParams,
+	useERC721SalePaymentParams,
+} from '../useERC721SalePaymentParams';
+
+// Mock wagmi's useAccount hook
+vi.mock('wagmi', async () => {
+	const actual = await vi.importActual('wagmi');
+	return {
+		...actual,
+		useAccount: vi.fn(() => ({
+			address: '0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266' as Address,
+		})),
+	};
+});
+
+// Mock store hooks
+vi.mock('../../store', () => ({
+	useOnSuccess: vi.fn(() => vi.fn()),
+	useOnError: vi.fn(() => vi.fn()),
+}));
+
+const mockSalesContractAddress = '0x1234567890123456789012345678901234567890';
+const mockCollectionAddress = '0xabcdefabcdefabcdefabcdefabcdefabcdefabcd';
+const mockPrice = '1000000000000000000'; // 1 ETH in wei
+const mockCurrencyAddress = '0x0000000000000000000000000000000000000000'; // ETH
+
+describe('getERC721SalePaymentParams', () => {
+	it('should generate correct payment parameters', async () => {
+		const params = {
+			chainId: 1,
+			address: '0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266' as Address,
+			salesContractAddress: mockSalesContractAddress,
+			collectionAddress: mockCollectionAddress,
+			price: BigInt(mockPrice),
+			currencyAddress: mockCurrencyAddress,
+			callbacks: {
+				onSuccess: vi.fn(),
+				onError: vi.fn(),
+			},
+			customCreditCardProviderCallback: undefined,
+			skipNativeBalanceCheck: false,
+			nativeTokenAddress: undefined,
+			checkoutProvider: undefined,
+			quantity: 1,
+		};
+
+		const result = await getERC721SalePaymentParams(params);
+
+		expect(result).toMatchObject({
+			chain: 1,
+			collectibles: [
+				{
+					quantity: '1',
+					decimals: 0,
+				},
+			],
+			currencyAddress: mockCurrencyAddress,
+			price: mockPrice,
+			targetContractAddress: mockSalesContractAddress,
+			collectionAddress: mockCollectionAddress,
+			recipientAddress: '0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266',
+			enableMainCurrencyPayment: true,
+			enableSwapPayments: true,
+			creditCardProviders: [],
+		});
+
+		expect(result.txData).toBeDefined();
+		expect(typeof result.txData).toBe('string');
+		expect(result.txData).toMatch(/^0x/);
+		expect(result.onSuccess).toBeInstanceOf(Function);
+		expect(result.onError).toBe(params.callbacks.onError);
+		expect(result.onClose).toBeInstanceOf(Function);
+	});
+
+	it('should handle custom checkout provider', async () => {
+		const params = {
+			chainId: 1,
+			address: '0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266' as Address,
+			salesContractAddress: mockSalesContractAddress,
+			collectionAddress: mockCollectionAddress,
+			price: BigInt(mockPrice),
+			currencyAddress: mockCurrencyAddress,
+			callbacks: undefined,
+			customCreditCardProviderCallback: undefined,
+			skipNativeBalanceCheck: false,
+			nativeTokenAddress: undefined,
+			checkoutProvider: 'stripe',
+			quantity: 1,
+		};
+
+		const result = await getERC721SalePaymentParams(params);
+		expect(result.creditCardProviders).toEqual(['stripe']);
+	});
+
+	it('should handle custom credit card provider callback', async () => {
+		const customCallback = vi.fn();
+		const params = {
+			chainId: 1,
+			address: '0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266' as Address,
+			salesContractAddress: mockSalesContractAddress,
+			collectionAddress: mockCollectionAddress,
+			price: BigInt(mockPrice),
+			currencyAddress: mockCurrencyAddress,
+			callbacks: undefined,
+			customCreditCardProviderCallback: customCallback,
+			skipNativeBalanceCheck: false,
+			nativeTokenAddress: undefined,
+			checkoutProvider: undefined,
+			quantity: 1,
+		};
+
+		const result = await getERC721SalePaymentParams(params);
+		expect(result.creditCardProviders).toEqual(['custom']);
+		expect(result.customProviderCallback).toBeInstanceOf(Function);
+	});
+
+	it('should handle multiple quantities', async () => {
+		const params = {
+			chainId: 1,
+			address: '0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266' as Address,
+			salesContractAddress: mockSalesContractAddress,
+			collectionAddress: mockCollectionAddress,
+			price: BigInt(mockPrice),
+			currencyAddress: mockCurrencyAddress,
+			callbacks: undefined,
+			customCreditCardProviderCallback: undefined,
+			skipNativeBalanceCheck: false,
+			nativeTokenAddress: undefined,
+			checkoutProvider: undefined,
+			quantity: 5,
+		};
+
+		const result = await getERC721SalePaymentParams(params);
+		expect(result.collectibles[0].quantity).toBe('5');
+	});
+});
+
+describe('useERC721SalePaymentParams', () => {
+	beforeEach(() => {
+		vi.clearAllMocks();
+	});
+
+	afterEach(() => {
+		vi.restoreAllMocks();
+	});
+
+	it('should return loading state initially', () => {
+		const { result } = renderHook(() =>
+			useERC721SalePaymentParams({
+				salesContractAddress: mockSalesContractAddress,
+				collectionAddress: mockCollectionAddress,
+				price: mockPrice,
+				currencyAddress: mockCurrencyAddress,
+				enabled: true,
+				chainId: 1,
+				quantity: 1,
+			}),
+		);
+
+		expect(result.current.isLoading).toBe(true);
+		expect(result.current.data).toBeUndefined();
+	});
+
+	it('should handle skipToken when disabled', () => {
+		const { result } = renderHook(() =>
+			useERC721SalePaymentParams({
+				salesContractAddress: mockSalesContractAddress,
+				collectionAddress: mockCollectionAddress,
+				price: mockPrice,
+				currencyAddress: mockCurrencyAddress,
+				enabled: false,
+				chainId: 1,
+				quantity: 1,
+			}),
+		);
+
+		// Should not be loading when disabled
+		expect(result.current.isLoading).toBe(false);
+		expect(result.current.isFetching).toBe(false);
+		expect(result.current.data).toBeUndefined();
+	});
+
+	it('should not fetch when wallet is not connected', async () => {
+		const { useAccount } = vi.mocked(await import('wagmi'));
+		useAccount.mockReturnValue({
+			address: undefined,
+			isConnected: false,
+			isConnecting: false,
+			isDisconnected: true,
+			isReconnecting: false,
+			connector: null,
+			addresses: undefined,
+			chain: undefined,
+			chainId: undefined,
+			status: 'disconnected',
+		} as never);
+
+		const { result } = renderHook(() =>
+			useERC721SalePaymentParams({
+				salesContractAddress: mockSalesContractAddress,
+				collectionAddress: mockCollectionAddress,
+				price: mockPrice,
+				currencyAddress: mockCurrencyAddress,
+				enabled: true,
+				chainId: 1,
+				quantity: 1,
+			}),
+		);
+
+		expect(result.current.isLoading).toBe(false);
+		expect(result.current.isFetching).toBe(false);
+		expect(result.current.data).toBeUndefined();
+	});
+
+	it('should not fetch when required parameters are missing', () => {
+		const { result } = renderHook(() =>
+			useERC721SalePaymentParams({
+				salesContractAddress: undefined,
+				collectionAddress: mockCollectionAddress,
+				price: mockPrice,
+				currencyAddress: mockCurrencyAddress,
+				enabled: true,
+				chainId: 1,
+				quantity: 1,
+			}),
+		);
+
+		expect(result.current.isLoading).toBe(false);
+		expect(result.current.isFetching).toBe(false);
+		expect(result.current.data).toBeUndefined();
+	});
+
+	it('should use proper query key', () => {
+		const args = {
+			salesContractAddress: mockSalesContractAddress,
+			collectionAddress: mockCollectionAddress,
+			price: mockPrice,
+			currencyAddress: mockCurrencyAddress,
+			enabled: true,
+			chainId: 1,
+			quantity: 1,
+		};
+
+		const { result } = renderHook(() => useERC721SalePaymentParams(args));
+
+		// Query should use the proper key structure
+		expect(result.current.isLoading).toBe(true);
+	});
+});

package/src/react/ui/modals/BuyModal/hooks/__tests__/{useFees.test.tsx → useMarketPlatformFee.test.tsx}

@@ -1,16 +1,15 @@
 import { renderHook } from '@test';
 import { avalanche, optimism } from 'viem/chains';
 import { beforeEach, describe, expect, it, vi } from 'vitest';
-import { MarketplaceType } from '../../../../../../types/new-marketplace-types';
 import { useMarketplaceConfig } from '../../../../../hooks';
-import { useFees } from '../useFees';
+import { useMarketPlatformFee } from '../useMarketPlatformFee';
 
 // Mock dependencies
 vi.mock('../../../../../hooks', () => ({
 	useMarketplaceConfig: vi.fn(),
 }));
 
-describe('useFees', () => {
+describe('useMarketPlatformFee', () => {
 	const defaultProps = {
 		chainId: 1,
 		collectionAddress: '0x123',
@@ -37,14 +36,14 @@ describe('useFees', () => {
 							itemsAddress: '0x456',
 							chainId: 1,
 							feePercentage: '5.0',
-							marketplaceType: MarketplaceType.MARKET,
+							marketplaceType: 'market',
 						},
 					],
 				},
 			},
 		});
 
-		const { result } = renderHook(() => useFees(defaultProps));
+		const { result } = renderHook(() => useMarketPlatformFee(defaultProps));
 
 		// Default fee should be 2.5%, which is 250 in BPS (basis points)
 		expect(result.current).toEqual({
@@ -69,7 +68,7 @@ describe('useFees', () => {
 							itemsAddress: collectionAddress,
 							chainId: chainId.toString(),
 							feePercentage: collectionFee,
-							marketplaceType: MarketplaceType.MARKET,
+							marketplaceType: 'market',
 						},
 					],
 				},
@@ -77,7 +76,7 @@ describe('useFees', () => {
 		});
 
 		const { result } = renderHook(() =>
-			useFees({ chainId, collectionAddress }),
+			useMarketPlatformFee({ chainId, collectionAddress }),
 		);
 
 		// 5.0% fee should be 500 in BPS (basis points)
@@ -90,7 +89,7 @@ describe('useFees', () => {
 	it('should use Avalanche/Optimism fee recipient for those chains', () => {
 		// Test Avalanche chain
 		const { result: avalancheResult } = renderHook(() =>
-			useFees({ ...defaultProps, chainId: avalanche.id }),
+			useMarketPlatformFee({ ...defaultProps, chainId: avalanche.id }),
 		);
 
 		expect(avalancheResult.current.receiver).toBe(
@@ -99,7 +98,7 @@ describe('useFees', () => {
 
 		// Test Optimism chain
 		const { result: optimismResult } = renderHook(() =>
-			useFees({ ...defaultProps, chainId: optimism.id }),
+			useMarketPlatformFee({ ...defaultProps, chainId: optimism.id }),
 		);
 
 		expect(optimismResult.current.receiver).toBe(
@@ -123,7 +122,7 @@ describe('useFees', () => {
 							itemsAddress: collectionAddress.toLowerCase(),
 							chainId: chainId.toString(),
 							feePercentage: collectionFee,
-							marketplaceType: MarketplaceType.MARKET,
+							marketplaceType: 'market',
 						},
 					],
 				},
@@ -131,7 +130,7 @@ describe('useFees', () => {
 		});
 
 		const { result } = renderHook(() =>
-			useFees({
+			useMarketPlatformFee({
 				chainId,
 				collectionAddress: collectionAddress.toUpperCase(),
 			}),