@0xsequence/marketplace-sdk 0.8.10 → 0.8.12

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

@@ -0,0 +1,225 @@
+import { skipToken } from '@tanstack/react-query';
+import { renderHook, waitFor } from '@test';
+import type { Address } from 'viem';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { useCheckoutOptionsSalesContract } from '../useCheckoutOptionsSalesContract';
+
+// Mock wagmi's useAccount hook
+vi.mock('wagmi', async () => {
+	const actual = await vi.importActual('wagmi');
+	return {
+		...actual,
+		useAccount: vi.fn(() => ({ address: '0xTestWallet' as Address })),
+	};
+});
+
+const mockContractAddress =
+	'0x1234567890123456789012345678901234567890' as Address;
+const mockCollectionAddress =
+	'0xabcdefabcdefabcdefabcdefabcdefabcdefabcd' as Address;
+
+describe('useCheckoutOptionsSalesContract', () => {
+	beforeEach(() => {
+		vi.clearAllMocks();
+	});
+
+	afterEach(() => {
+		vi.restoreAllMocks();
+	});
+
+	it('should fetch checkout options successfully', async () => {
+		const { result } = renderHook(() =>
+			useCheckoutOptionsSalesContract({
+				chainId: 1,
+				contractAddress: mockContractAddress,
+				collectionAddress: mockCollectionAddress,
+				items: [
+					{
+						quantity: '1',
+						tokenId: '1',
+					},
+				],
+			}),
+		);
+
+		// Initially loading
+		expect(result.current.isLoading).toBe(true);
+		expect(result.current.data).toBeUndefined();
+
+		// Wait for successful response
+		await waitFor(() => {
+			expect(result.current.isSuccess).toBe(true);
+		});
+
+		// Check the response
+		expect(result.current.data).toEqual({
+			options: {
+				crypto: 'all',
+				swap: [],
+				nftCheckout: [],
+				onRamp: [],
+			},
+		});
+	});
+
+	it('should handle skipToken', () => {
+		const { result } = renderHook(() =>
+			useCheckoutOptionsSalesContract(skipToken),
+		);
+
+		// Should not be loading when skipToken is passed
+		expect(result.current.isLoading).toBe(false);
+		expect(result.current.isFetching).toBe(false);
+		expect(result.current.data).toBeUndefined();
+	});
+
+	it('should handle multiple items', async () => {
+		const { result } = renderHook(() =>
+			useCheckoutOptionsSalesContract({
+				chainId: 137,
+				contractAddress: mockContractAddress,
+				collectionAddress: mockCollectionAddress,
+				items: [
+					{
+						quantity: '2',
+						tokenId: '1',
+					},
+					{
+						quantity: '1',
+						tokenId: '2',
+					},
+				],
+			}),
+		);
+
+		await waitFor(() => {
+			expect(result.current.isSuccess).toBe(true);
+		});
+
+		expect(result.current.data).toBeDefined();
+		expect(result.current.data?.options).toBeDefined();
+	});
+
+	it('should refetch when args change', async () => {
+		let chainIdProp = 1;
+		const itemsProp = [{ quantity: '1', tokenId: '1' }];
+
+		const { result, rerender } = renderHook(() =>
+			useCheckoutOptionsSalesContract({
+				chainId: chainIdProp,
+				contractAddress: mockContractAddress,
+				collectionAddress: mockCollectionAddress,
+				items: itemsProp,
+			}),
+		);
+
+		await waitFor(() => {
+			expect(result.current.isSuccess).toBe(true);
+		});
+
+		const firstData = result.current.data;
+
+		// Change chainId
+		chainIdProp = 137;
+		rerender();
+
+		await waitFor(() => {
+			expect(result.current.isFetching).toBe(true);
+		});
+
+		await waitFor(() => {
+			expect(result.current.isFetching).toBe(false);
+		});
+
+		// Data should still be the same (mocked response doesn't change)
+		expect(result.current.data).toEqual(firstData);
+	});
+
+	it('should use wallet address from useAccount', async () => {
+		const { useAccount } = await import('wagmi');
+		const mockUseAccount = vi.mocked(useAccount);
+
+		// Set a specific address
+		mockUseAccount.mockReturnValue({
+			address: '0xSpecificWallet' as Address,
+			isConnected: true,
+			isConnecting: false,
+			isDisconnected: false,
+			isReconnecting: false,
+			connector: null,
+			addresses: undefined,
+			chain: undefined,
+			chainId: undefined,
+			status: 'connected',
+		} as unknown as ReturnType<typeof useAccount>);
+
+		const { result } = renderHook(() =>
+			useCheckoutOptionsSalesContract({
+				chainId: 1,
+				contractAddress: mockContractAddress,
+				collectionAddress: mockCollectionAddress,
+				items: [{ quantity: '1', tokenId: '1' }],
+			}),
+		);
+
+		await waitFor(() => {
+			expect(result.current.isSuccess).toBe(true);
+		});
+
+		expect(result.current.data).toBeDefined();
+	});
+
+	it('should handle when wallet is not connected', async () => {
+		const { useAccount } = await import('wagmi');
+		const mockUseAccount = vi.mocked(useAccount);
+
+		// No wallet connected
+		mockUseAccount.mockReturnValue({
+			address: undefined,
+			isConnected: false,
+			isConnecting: false,
+			isDisconnected: true,
+			isReconnecting: false,
+			connector: null,
+			addresses: undefined,
+			chain: undefined,
+			chainId: undefined,
+			status: 'disconnected',
+		} as unknown as ReturnType<typeof useAccount>);
+
+		const { result } = renderHook(() =>
+			useCheckoutOptionsSalesContract({
+				chainId: 1,
+				contractAddress: mockContractAddress,
+				collectionAddress: mockCollectionAddress,
+				items: [{ quantity: '1', tokenId: '1' }],
+			}),
+		);
+
+		// The hook will still try to fetch even without a wallet (using undefined)
+		// Wait for it to complete
+		await waitFor(() => {
+			expect(result.current.isSuccess).toBe(true);
+		});
+
+		// The API should still return data even without wallet
+		expect(result.current.data).toBeDefined();
+	});
+
+	it('should handle empty items array', async () => {
+		const { result } = renderHook(() =>
+			useCheckoutOptionsSalesContract({
+				chainId: 1,
+				contractAddress: mockContractAddress,
+				collectionAddress: mockCollectionAddress,
+				items: [],
+			}),
+		);
+
+		await waitFor(() => {
+			expect(result.current.isSuccess).toBe(true);
+		});
+
+		expect(result.current.data).toBeDefined();
+	});
+});

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

@@ -23,7 +23,7 @@ describe('useCollectionDetailsPolling', () => {
 		// Mock initial syncing state
 		const syncingCollection = {
 			...mockCollection,
-			status: CollectionStatus.syncing_metadata,
+			status: CollectionStatus.syncing_orders,
 		};
 		let requestCount = 0;
 
@@ -58,7 +58,7 @@ describe('useCollectionDetailsPolling', () => {
 		});
 
 		// Should be in syncing state
-		expect(result.current.data?.status).toBe(CollectionStatus.syncing_metadata);
+		expect(result.current.data?.status).toBe(CollectionStatus.syncing_orders);
 
 		// Advance timer and run pending timers to trigger next poll
 		await vi.advanceTimersByTimeAsync(2000);
@@ -79,7 +79,7 @@ describe('useCollectionDetailsPolling', () => {
 	it('should stop polling after max attempts', async () => {
 		const syncingCollection = {
 			...mockCollection,
-			status: CollectionStatus.syncing_metadata,
+			status: CollectionStatus.syncing_orders,
 		};
 		let requestCount = 0;
 

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

@@ -85,22 +85,6 @@ describe('useFilters', () => {
 		`);
 	});
 
-	it('should validate input parameters', async () => {
-		const invalidArgs: UseFiltersArgs = {
-			...defaultArgs,
-			// @ts-expect-error
-			chainId: {}, // Using an object instead of a string/number will fail validation
-		};
-
-		const { result } = renderHook(() => useFilters(invalidArgs));
-
-		await waitFor(() => {
-			expect(result.current.isError).toBe(true);
-		});
-
-		expect(result.current.error).toBeDefined();
-	});
-
 	it('should return filter values in correct format', async () => {
 		const { result } = renderHook(() => useFilters(defaultArgs));
 

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

@@ -3,7 +3,6 @@ import { http, HttpResponse } from 'msw';
 import { zeroAddress } from 'viem';
 import { describe, expect, it, vi } from 'vitest';
 import {
-	createMockStep,
 	createMockSteps,
 	mockMarketplaceEndpoint,
 } from '../../_internal/api/__mocks__/marketplace.msw';
@@ -85,7 +84,7 @@ describe('useGenerateCancelTransaction', () => {
 		);
 
 		const { result } = renderHook(() =>
-			useGenerateCancelTransaction(invalidArgs),
+			useGenerateCancelTransaction(defaultArgs),
 		);
 
 		await act(async () => {
@@ -124,7 +123,7 @@ describe('useGenerateCancelTransaction', () => {
 
 		await waitFor(() => {
 			expect(onSuccess).toHaveBeenCalledWith(
-				[createMockStep(StepType.cancel)],
+				createMockSteps([StepType.cancel]),
 				defaultArgs,
 				undefined,
 			);

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

@@ -98,20 +98,4 @@ describe('useHighestOffer', () => {
 		expect(result.current.data).toBeDefined();
 		expect(result.current.error).toBeNull();
 	});
-
-	it('should validate input parameters', async () => {
-		const invalidArgs = {
-			...defaultArgs,
-			chainId: 'invalid-chain' as string, // Properly typed as string
-		};
-
-		// @ts-expect-error - for testing purposes
-		const { result } = renderHook(() => useHighestOffer(invalidArgs));
-
-		await waitFor(() => {
-			expect(result.current.isError).toBe(true);
-		});
-
-		expect(result.current.error).toBeDefined();
-	});
 });

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

@@ -1,11 +1,7 @@
 import { renderHook, server, waitFor } from '@test';
 import { http, HttpResponse } from 'msw';
-import { zeroAddress } from 'viem';
+import { type Address, zeroAddress } from 'viem';
 import { beforeEach, describe, expect, it } from 'vitest';
-import {
-	createLookupMarketplaceConfigHandler,
-	mockConfig,
-} from '../../_internal/api/__mocks__/builder.msw';
 import {
 	mockIndexerEndpoint,
 	mockTokenBalance,
@@ -22,8 +18,7 @@ mockCollectibleOrder.metadata.tokenId = '1';
 
 describe('useInventory', () => {
 	const defaultArgs: UseInventoryArgs = {
-		accountAddress:
-			'0x1234567890123456789012345678901234567890' as `0x${string}`,
+		accountAddress: '0x1234567890123456789012345678901234567890' as Address,
 		chainId: 1,
 		collectionAddress: zeroAddress,
 	};
@@ -67,7 +62,7 @@ describe('useInventory', () => {
 				...defaultArgs,
 				// Add a unique key to avoid caching
 				collectionAddress:
-					'0xdeadbeef0000000000000000000000000000dead' as `0x${string}`,
+					'0xdeadbeef0000000000000000000000000000dead' as Address,
 			}),
 		);
 
@@ -97,7 +92,7 @@ describe('useInventory', () => {
 		const newArgs = {
 			...defaultArgs,
 			collectionAddress:
-				'0x1234567890123456789012345678901234567890' as `0x${string}`,
+				'0x1234567890123456789012345678901234567890' as Address,
 		};
 
 		rerender(() => useInventory(newArgs));
@@ -128,36 +123,6 @@ describe('useInventory', () => {
 		expect(result.current.isFetched).toBe(false);
 	});
 
-	it('should use isLaos721 flag from marketplaceConfig', async () => {
-		// Setup config with LAOS collection
-		const laosCollectionAddress = '0x1234567890123456789012345678901234567890';
-		const configWithLaos = {
-			...mockConfig,
-			collections: [
-				{
-					...mockConfig.collections[0],
-					address: laosCollectionAddress,
-					isLAOSERC721: true,
-				},
-			],
-		};
-		server.use(createLookupMarketplaceConfigHandler(configWithLaos));
-
-		const laosArgs: UseInventoryArgs = {
-			...defaultArgs,
-			collectionAddress: laosCollectionAddress as `0x${string}`,
-		};
-
-		const { result } = renderHook(() => useInventory(laosArgs));
-
-		await waitFor(() => {
-			expect(result.current.isLoading).toBe(false);
-		});
-
-		expect(result.current.data).toBeDefined();
-		expect(result.current.isSuccess).toBe(true);
-	});
-
 	it('should fetch data from indexer when marketplace API has no more results', async () => {
 		// Mock marketplace API with empty results
 		server.use(
@@ -245,10 +210,9 @@ describe('useInventory', () => {
 		// Use unique test args to avoid caching issues
 		const testArgs = {
 			...defaultArgs,
-			accountAddress:
-				'0xabcdef1234567890abcdef1234567890abcdef12' as `0x${string}`,
+			accountAddress: '0xabcdef1234567890abcdef1234567890abcdef12' as Address,
 			collectionAddress:
-				'0xabcdef1234567890abcdef1234567890abcdef12' as `0x${string}`,
+				'0xabcdef1234567890abcdef1234567890abcdef12' as Address,
 		};
 
 		const { result } = renderHook(() => useInventory(testArgs));

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

@@ -1,15 +1,13 @@
 import { renderHook, server, waitFor } from '@test';
 import { http, HttpResponse } from 'msw';
+import type { Address } from 'viem';
 import { describe, expect, it } from 'vitest';
-import { MarketplaceType, OrderbookKind } from '../../../types';
+import { OrderbookKind } from '../../_internal';
 import {
-	createLookupMarketplaceConfigHandler,
+	createLookupMarketplaceHandler,
 	mockConfig,
 } from '../../_internal/api/__mocks__/builder.msw';
-import {
-	mockEthCollection,
-	mockPolCollection,
-} from '../../_internal/api/__mocks__/metadata.msw';
+import { mockEthCollection } from '../../_internal/api/__mocks__/metadata.msw';
 import { useListCollections } from '../useListCollections';
 
 describe('useListCollections', () => {
@@ -22,16 +20,16 @@ describe('useListCollections', () => {
 		});
 
 		// Verify the data matches our mock
-		expect(result.current.data).toEqual([mockEthCollection, mockPolCollection]);
+		expect(result.current.data).toMatchSnapshot();
 		expect(result.current.error).toBeNull();
 	});
 
 	it('should handle empty collections', async () => {
 		// Mock marketplace config with empty collections
 		server.use(
-			createLookupMarketplaceConfigHandler({
+			createLookupMarketplaceHandler({
 				...mockConfig,
-				collections: [],
+				marketCollections: [],
 			}),
 		);
 
@@ -41,65 +39,35 @@ describe('useListCollections', () => {
 			expect(result.current.data).toBeDefined();
 		});
 
-		expect(result.current.data).toEqual([]);
+		expect(result.current.data).toMatchSnapshot();
 		expect(result.current.error).toBeNull();
 	});
 
-	it('should handle error states', async () => {
-		// Mock marketplace config with collection
-		server.use(
-			createLookupMarketplaceConfigHandler({
-				...mockConfig,
-				collections: [
-					{
-						chainId: 1,
-						address:
-							'0x1234567890123456789012345678901234567890' as `0x${string}`,
-						feePercentage: 2.5,
-						marketplaceType: MarketplaceType.ORDERBOOK,
-						currencyOptions: [],
-						exchanges: [],
-						bannerUrl: '',
-						destinationMarketplace: OrderbookKind.sequence_marketplace_v2,
-					},
-				],
-			}),
-			http.post('*/rpc/Metadata/GetContractInfoBatch', () => {
-				return new HttpResponse(
-					JSON.stringify({ error: { message: 'Failed to fetch collections' } }),
-					{ status: 500 },
-				);
-			}),
-		);
-
-		const { result } = renderHook(() => useListCollections());
-
-		await waitFor(() => {
-			expect(result.current.isError).toBe(true);
-		});
-
-		expect(result.current.error).toBeDefined();
-		expect(result.current.data).toBeUndefined();
-	});
-
 	it('should handle disabled queries', async () => {
 		let requestMade = false;
 
 		// Mock marketplace config with collection
 		server.use(
-			createLookupMarketplaceConfigHandler({
+			createLookupMarketplaceHandler({
 				...mockConfig,
-				collections: [
+				marketCollections: [
 					{
+						id: 1,
+						projectId: 1,
+						contractType: 'ERC721',
 						chainId: 1,
-						address:
-							'0x1234567890123456789012345678901234567890' as `0x${string}`,
+						itemsAddress:
+							'0x1234567890123456789012345678901234567890' as Address,
 						feePercentage: 2.5,
-						marketplaceType: MarketplaceType.ORDERBOOK,
 						currencyOptions: [],
-						exchanges: [],
 						bannerUrl: '',
-						destinationMarketplace: OrderbookKind.sequence_marketplace_v2,
+						destinationMarketplace: OrderbookKind.opensea,
+						filterSettings: {
+							filterOrder: ['Category', 'Level', 'Element'],
+							exclusions: [],
+						},
+						createdAt: new Date('2025-03-16T13:04:16.098Z').toISOString(),
+						updatedAt: new Date('2025-03-16T13:04:16.098Z').toISOString(),
 					},
 				],
 			}),
@@ -129,14 +97,13 @@ describe('useListCollections', () => {
 	});
 
 	it('should handle multiple collections from different chains', async () => {
-		// TODO: This test should be more robust, make sure we validate that the marketplace config has multiple chains
-		// then the to equal should just check that we are fetching the data from those
 		const { result } = renderHook(() => useListCollections());
 
 		await waitFor(() => {
 			expect(result.current.data).toBeDefined();
 		});
 
-		expect(result.current.data).toEqual([mockEthCollection, mockPolCollection]);
+		const set = new Set(result.current.data?.map((c) => c.chainId));
+		expect(set.size).toBeGreaterThan(1);
 	});
 });

package/src/react/hooks/__tests__/{useCurrencies.test.tsx → useMarketCurrencies.test.tsx}

@@ -1,21 +1,22 @@
 import { renderHook, server, waitFor } from '@test';
 import { USDC_ADDRESS } from '@test/const';
 import { http, HttpResponse } from 'msw';
+import type { Address } from 'viem';
 import { describe, expect, it } from 'vitest';
 import { mockConfig } from '../../_internal/api/__mocks__/builder.msw';
 import {
 	mockCurrencies,
 	mockMarketplaceEndpoint,
 } from '../../_internal/api/__mocks__/marketplace.msw';
-import { useCurrencies } from '../useCurrencies';
+import { useMarketCurrencies } from '../useMarketCurrencies';
 
-describe('useCurrencies', () => {
+describe('useMarketCurrencies', () => {
 	const defaultArgs = {
 		chainId: 1,
 	};
 
 	it('should fetch currencies successfully', async () => {
-		const { result } = renderHook(() => useCurrencies(defaultArgs));
+		const { result } = renderHook(() => useMarketCurrencies(defaultArgs));
 
 		// Initially loading
 		expect(result.current.isLoading).toBe(true);
@@ -37,7 +38,7 @@ describe('useCurrencies', () => {
 			includeNativeCurrency: false,
 		};
 
-		const { result } = renderHook(() => useCurrencies(argsWithoutNative));
+		const { result } = renderHook(() => useMarketCurrencies(argsWithoutNative));
 
 		await waitFor(() => {
 			expect(result.current.isLoading).toBe(false);
@@ -51,10 +52,11 @@ describe('useCurrencies', () => {
 	it('should filter currencies by collection address', async () => {
 		const args = {
 			...defaultArgs,
-			collectionAddress: mockConfig.collections[1].address,
-		} satisfies Parameters<typeof useCurrencies>[0];
+			collectionAddress: mockConfig.marketCollections[1]
+				.itemsAddress as Address,
+		} satisfies Parameters<typeof useMarketCurrencies>[0];
 
-		const { result } = renderHook(() => useCurrencies(args));
+		const { result } = renderHook(() => useMarketCurrencies(args));
 
 		await waitFor(() => {
 			expect(result.current.isLoading).toBe(false);
@@ -64,7 +66,7 @@ describe('useCurrencies', () => {
 			(c) => c.contractAddress,
 		);
 		expect(currencyAddresses).toEqual(
-			mockConfig.collections[1].currencyOptions,
+			mockConfig.marketCollections[1].currencyOptions,
 		);
 	});
 
@@ -79,7 +81,7 @@ describe('useCurrencies', () => {
 			}),
 		);
 
-		const { result } = renderHook(() => useCurrencies(defaultArgs));
+		const { result } = renderHook(() => useMarketCurrencies(defaultArgs));
 
 		await waitFor(() => {
 			expect(result.current.isError).toBe(true);
@@ -90,7 +92,9 @@ describe('useCurrencies', () => {
 	});
 
 	it('should refetch when chainId changes', async () => {
-		const { result, rerender } = renderHook(() => useCurrencies(defaultArgs));
+		const { result, rerender } = renderHook(() =>
+			useMarketCurrencies(defaultArgs),
+		);
 
 		// Wait for initial data
 		await waitFor(() => {
@@ -103,7 +107,7 @@ describe('useCurrencies', () => {
 			chainId: 5,
 		};
 
-		rerender(() => useCurrencies(newArgs));
+		rerender(() => useMarketCurrencies(newArgs));
 
 		// Wait for new data
 		await waitFor(() => {
@@ -123,7 +127,7 @@ describe('useCurrencies', () => {
 			},
 		};
 
-		const { result } = renderHook(() => useCurrencies(argsWithQuery));
+		const { result } = renderHook(() => useMarketCurrencies(argsWithQuery));
 
 		// Should not fetch when disabled
 		expect(result.current.isLoading).toBe(false);
@@ -137,7 +141,9 @@ describe('useCurrencies', () => {
 			currencyOptions: [USDC_ADDRESS],
 		};
 
-		const { result } = renderHook(() => useCurrencies(argsWithCombinedFilters));
+		const { result } = renderHook(() =>
+			useMarketCurrencies(argsWithCombinedFilters),
+		);
 
 		await waitFor(() => {
 			expect(result.current.isLoading).toBe(false);
@@ -168,9 +174,9 @@ describe('useCurrencies', () => {
 			...defaultArgs,
 			includeNativeCurrency: false,
 			collectionAddress: '0x1234567890123456789012345678901234567890',
-		} satisfies Parameters<typeof useCurrencies>[0];
+		} satisfies Parameters<typeof useMarketCurrencies>[0];
 
-		const { result } = renderHook(() => useCurrencies(args));
+		const { result } = renderHook(() => useMarketCurrencies(args));
 
 		await waitFor(() => {
 			expect(result.current.isLoading).toBe(false);