@0xsequence/marketplace-sdk 0.9.0 → 0.10.0

package/src/react/hooks/__tests__/useBalanceOfCollectible.laos.test.tsx

@@ -0,0 +1,367 @@
+import { renderHook, server, waitFor } from '@test';
+import { HttpResponse, http } from 'msw';
+import { afterEach, describe, expect, it } from 'vitest';
+import { ContractType } from '../../_internal';
+import {
+	mockIndexerEndpoint,
+	mockTokenBalance,
+} from '../../_internal/api/__mocks__/indexer.msw';
+import {
+	laosHandlers,
+	mockTokenBalancesResponse,
+} from '../../_internal/api/__mocks__/laos.msw';
+import { useBalanceOfCollectible } from '../useBalanceOfCollectible';
+
+describe('useBalanceOfCollectible with LAOS', () => {
+	const defaultArgs = {
+		collectionAddress:
+			'0x1234567890123456789012345678901234567890' as `0x${string}`,
+		collectableId: '1',
+		userAddress:
+			'0xuser1234567890123456789012345678901234567890' as `0x${string}`,
+		chainId: 11155111,
+	};
+
+	// Mock marketplace config API response with LAOS collection
+	const laosMarketplaceConfigResponse = {
+		marketplace: {
+			projectId: 1,
+			settings: {
+				style: {},
+				publisherId: 'test-publisher',
+				title: 'Test Marketplace',
+				socials: {
+					twitter: '',
+					discord: '',
+					website: '',
+					tiktok: '',
+					instagram: '',
+					youtube: '',
+				},
+				faviconUrl: '',
+				walletOptions: {
+					walletType: 'UNIVERSAL',
+					oidcIssuers: {},
+					connectors: [],
+					includeEIP6963Wallets: false,
+				},
+				logoUrl: '',
+				fontUrl: '',
+			},
+			market: {
+				enabled: true,
+				title: 'Test Market',
+				bannerUrl: 'https://example.com/banner.png',
+				ogImage: 'https://example.com/og.png',
+			},
+			shop: {
+				enabled: false,
+				title: '',
+				bannerUrl: '',
+				ogImage: '',
+			},
+		},
+		marketCollections: [
+			{
+				id: 1,
+				projectId: 1,
+				chainId: 11155111,
+				itemsAddress: '0x1234567890123456789012345678901234567890',
+				contractType: ContractType.LAOS_ERC_721,
+				bannerUrl: 'https://example.com/banner.png',
+				feePercentage: 0,
+				currencyOptions: [],
+				destinationMarketplace: 'sequence_marketplace_v2',
+			},
+			{
+				id: 2,
+				projectId: 1,
+				chainId: 11155111,
+				itemsAddress: '0x9876543210987654321098765432109876543210',
+				contractType: ContractType.ERC721,
+				bannerUrl: 'https://example.com/banner2.png',
+				feePercentage: 0,
+				currencyOptions: [],
+				destinationMarketplace: 'sequence_marketplace_v2',
+			},
+		],
+		shopCollections: [],
+	};
+
+	// Setup handlers for LAOS and marketplace config
+	afterEach(() => {
+		server.resetHandlers();
+	});
+
+	it('should use LAOS API when collection is LAOS_ERC_721', async () => {
+		// Add LAOS handlers and marketplace config handler
+		server.use(
+			...laosHandlers,
+			http.post('*/rpc/MarketplaceService/LookupMarketplace', () => {
+				return HttpResponse.json(laosMarketplaceConfigResponse);
+			}),
+		);
+
+		const { result } = renderHook(() => useBalanceOfCollectible(defaultArgs));
+
+		// Initially loading
+		expect(result.current.isLoading).toBe(true);
+
+		// Wait for the query to complete
+		await waitFor(() => {
+			expect(result.current.isSuccess).toBe(true);
+		});
+
+		// Should return LAOS API response (first balance)
+		expect(result.current.data).toEqual(mockTokenBalancesResponse.balances[0]);
+		expect(result.current.data?.balance).toBe('5');
+		expect(result.current.data?.contractInfo?.type).toBe('LAOS-ERC-721');
+	});
+
+	it('should use indexer API when collection is regular ERC_721', async () => {
+		const regularCollectionArgs = {
+			...defaultArgs,
+			collectionAddress:
+				'0x9876543210987654321098765432109876543210' as `0x${string}`,
+		};
+
+		server.use(
+			http.post('*/rpc/MarketplaceService/LookupMarketplace', () => {
+				return HttpResponse.json(laosMarketplaceConfigResponse);
+			}),
+			http.post(mockIndexerEndpoint('GetTokenBalances'), () => {
+				return HttpResponse.json({
+					page: { page: 1, pageSize: 10, more: false },
+					balances: [mockTokenBalance],
+				});
+			}),
+		);
+
+		const { result } = renderHook(() =>
+			useBalanceOfCollectible(regularCollectionArgs),
+		);
+
+		await waitFor(() => {
+			expect(result.current.isSuccess).toBe(true);
+		});
+
+		// Should return indexer API response
+		expect(result.current.data).toEqual(mockTokenBalance);
+		expect(result.current.data?.contractInfo?.type).toBe('ERC721');
+	});
+
+	it('should handle LAOS API errors gracefully', async () => {
+		const errorArgs = {
+			...defaultArgs,
+			userAddress:
+				'0x0000000000000000000000000000000000000001' as `0x${string}`, // Special address for 500 error
+		};
+
+		server.use(
+			...laosHandlers,
+			http.post('*/rpc/MarketplaceService/LookupMarketplace', () => {
+				return HttpResponse.json(laosMarketplaceConfigResponse);
+			}),
+		);
+
+		const { result } = renderHook(() => useBalanceOfCollectible(errorArgs));
+
+		await waitFor(() => {
+			expect(result.current.isError).toBe(true);
+		});
+
+		expect(result.current.error).toBeDefined();
+	});
+
+	it('should return null when LAOS API returns empty balances', async () => {
+		const emptyBalanceArgs = {
+			...defaultArgs,
+			userAddress:
+				'0x0000000000000000000000000000000000000003' as `0x${string}`, // Special address for empty response
+		};
+
+		server.use(
+			...laosHandlers,
+			http.post('*/rpc/MarketplaceService/LookupMarketplace', () => {
+				return HttpResponse.json(laosMarketplaceConfigResponse);
+			}),
+		);
+
+		const { result } = renderHook(() =>
+			useBalanceOfCollectible(emptyBalanceArgs),
+		);
+
+		await waitFor(() => {
+			expect(result.current.isSuccess).toBe(true);
+		});
+
+		expect(result.current.data).toBeNull();
+	});
+
+	it('should auto-detect LAOS from marketplace config', async () => {
+		server.use(
+			...laosHandlers,
+			http.post('*/rpc/MarketplaceService/LookupMarketplace', () => {
+				return HttpResponse.json(laosMarketplaceConfigResponse);
+			}),
+		);
+
+		const { result } = renderHook(() => useBalanceOfCollectible(defaultArgs));
+
+		await waitFor(() => {
+			expect(result.current.isSuccess).toBe(true);
+		});
+
+		// Verify it used LAOS API (returns LAOS-specific data structure)
+		expect(result.current.data?.contractInfo?.type).toBe('LAOS-ERC-721');
+		expect(result.current.data?.tokenMetadata).toBeDefined();
+	});
+
+	it('should fallback to indexer when marketplace config is unavailable', async () => {
+		// No marketplace config handler - should fallback to indexer
+		server.use(
+			http.post(mockIndexerEndpoint('GetTokenBalances'), () => {
+				return HttpResponse.json({
+					page: { page: 1, pageSize: 10, more: false },
+					balances: [mockTokenBalance],
+				});
+			}),
+		);
+
+		const { result } = renderHook(() => useBalanceOfCollectible(defaultArgs));
+
+		await waitFor(() => {
+			expect(result.current.isSuccess).toBe(true);
+		});
+
+		// Should use indexer since no marketplace config to determine LAOS
+		expect(result.current.data).toEqual(mockTokenBalance);
+		expect(result.current.data?.contractInfo?.type).toBe('ERC721');
+	});
+
+	it('should handle collection not found in marketplace config', async () => {
+		const unknownCollectionArgs = {
+			...defaultArgs,
+			collectionAddress:
+				'0x0000000000000000000000000000000000000999' as `0x${string}`, // Unknown collection
+		};
+
+		server.use(
+			http.post('*/rpc/MarketplaceService/LookupMarketplace', () => {
+				return HttpResponse.json(laosMarketplaceConfigResponse);
+			}),
+			http.post(mockIndexerEndpoint('GetTokenBalances'), () => {
+				return HttpResponse.json({
+					page: { page: 1, pageSize: 10, more: false },
+					balances: [mockTokenBalance],
+				});
+			}),
+		);
+
+		const { result } = renderHook(() =>
+			useBalanceOfCollectible(unknownCollectionArgs),
+		);
+
+		await waitFor(() => {
+			expect(result.current.isSuccess).toBe(true);
+		});
+
+		// Should fallback to indexer when collection not found in config
+		expect(result.current.data).toEqual(mockTokenBalance);
+		expect(result.current.data?.contractInfo?.type).toBe('ERC721');
+	});
+
+	it('should respect enabled query option for LAOS collections', () => {
+		server.use(
+			...laosHandlers,
+			http.post('*/rpc/MarketplaceService/LookupMarketplace', () => {
+				return HttpResponse.json(laosMarketplaceConfigResponse);
+			}),
+		);
+
+		const { result } = renderHook(() =>
+			useBalanceOfCollectible({
+				...defaultArgs,
+				query: {
+					enabled: false,
+				},
+			}),
+		);
+
+		expect(result.current.isLoading).toBe(false);
+		expect(result.current.data).toBeUndefined();
+	});
+
+	it('should handle LAOS metadata correctly', async () => {
+		server.use(
+			...laosHandlers,
+			http.post('*/rpc/MarketplaceService/LookupMarketplace', () => {
+				return HttpResponse.json(laosMarketplaceConfigResponse);
+			}),
+		);
+
+		const { result } = renderHook(() => useBalanceOfCollectible(defaultArgs));
+
+		await waitFor(() => {
+			expect(result.current.isSuccess).toBe(true);
+		});
+
+		const balance = result.current.data;
+		expect(balance?.tokenMetadata).toBeDefined();
+		expect(balance?.tokenMetadata?.name).toBe('Test Token 1');
+		expect(balance?.tokenMetadata?.description).toBe(
+			'A test token for LAOS testing',
+		);
+		expect(balance?.tokenMetadata?.image).toBe(
+			'https://example.com/token1.png',
+		);
+		expect(balance?.tokenMetadata?.attributes).toEqual([
+			{
+				trait_type: 'Rarity',
+				value: 'Common',
+			},
+		]);
+	});
+
+	it('should pass correct parameters to LAOS API', async () => {
+		let capturedRequestBody: Record<string, unknown> = {};
+
+		server.use(
+			http.post('*/rpc/MarketplaceService/LookupMarketplace', () => {
+				return HttpResponse.json(laosMarketplaceConfigResponse);
+			}),
+			http.post(
+				'https://extensions.api.laosnetwork.io/token/GetTokenBalances',
+				async ({ request }) => {
+					const body = await request.json();
+					capturedRequestBody = body as Record<string, unknown>;
+					return HttpResponse.json(mockTokenBalancesResponse);
+				},
+			),
+		);
+
+		const { result } = renderHook(() => useBalanceOfCollectible(defaultArgs));
+
+		await waitFor(() => {
+			expect(result.current.isSuccess).toBe(true);
+		});
+
+		// Verify LAOS API was called with correct parameters
+		expect(capturedRequestBody).toMatchInlineSnapshot(`
+			{
+			  "accountAddress": "0xuser1234567890123456789012345678901234567890",
+			  "chainId": "11155111",
+			  "contractAddress": "0x1234567890123456789012345678901234567890",
+			  "includeMetadata": true,
+			  "page": {
+			    "sort": [
+			      {
+			        "column": "CREATED_AT",
+			        "order": "DESC",
+			      },
+			    ],
+			  },
+			}
+		`);
+	});
+});

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

@@ -0,0 +1,158 @@
+import { renderHook, server, waitFor } from '@test';
+import { HttpResponse, http } from 'msw';
+import { zeroAddress } from 'viem';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { useAccount } from 'wagmi';
+import { MarketplaceKind } from '../../_internal';
+import {
+	mockCheckoutOptions,
+	mockMarketplaceEndpoint,
+} from '../../_internal/api/__mocks__/marketplace.msw';
+import type { UseCheckoutOptionsParams } from '../useCheckoutOptions';
+import { useCheckoutOptions } from '../useCheckoutOptions';
+
+// Mock wagmi useAccount hook
+vi.mock('wagmi', () => ({
+	useAccount: vi.fn(),
+}));
+
+const mockUseAccount = vi.mocked(useAccount);
+
+describe('useCheckoutOptions', () => {
+	const defaultArgs: UseCheckoutOptionsParams = {
+		chainId: 1,
+		orders: [
+			{
+				collectionAddress: zeroAddress,
+				orderId: '123',
+				marketplace: MarketplaceKind.sequence_marketplace_v2,
+			},
+		],
+		additionalFee: 0,
+		query: {},
+	};
+
+	beforeEach(() => {
+		mockUseAccount.mockReturnValue({
+			address: zeroAddress,
+		} as unknown as ReturnType<typeof useAccount>);
+	});
+
+	it('should fetch checkout options successfully', async () => {
+		const { result } = renderHook(() => useCheckoutOptions(defaultArgs));
+
+		// Initially loading
+		expect(result.current.isLoading).toBe(true);
+		expect(result.current.data).toBeUndefined();
+
+		// Wait for data to be loaded
+		await waitFor(() => {
+			expect(result.current.isLoading).toBe(false);
+		});
+
+		// Verify the data matches our mock
+		expect(result.current.data).toEqual(mockCheckoutOptions);
+		expect(result.current.error).toBeNull();
+	});
+
+	it('should handle error states', async () => {
+		// Override the handler for this test to return an error
+		server.use(
+			http.post(mockMarketplaceEndpoint('CheckoutOptionsMarketplace'), () => {
+				return HttpResponse.json(
+					{ error: { message: 'Failed to fetch checkout options' } },
+					{ status: 500 },
+				);
+			}),
+		);
+
+		const { result } = renderHook(() => useCheckoutOptions(defaultArgs));
+
+		await waitFor(() => {
+			expect(result.current.isError).toBe(true);
+		});
+
+		expect(result.current.error).toBeDefined();
+		expect(result.current.data).toBeUndefined();
+	});
+
+	it('should refetch when args change', async () => {
+		const { result, rerender } = renderHook(() =>
+			useCheckoutOptions(defaultArgs),
+		);
+
+		// Wait for initial data
+		await waitFor(() => {
+			expect(result.current.isLoading).toBe(false);
+		});
+
+		// Change args and rerender
+		const firstOrder = defaultArgs.orders?.[0];
+		if (!firstOrder) throw new Error('Expected defaultArgs.orders to exist');
+
+		const newArgs = {
+			...defaultArgs,
+			orders: [
+				{
+					...firstOrder,
+					orderId: '456',
+				},
+			],
+		};
+
+		rerender(() => useCheckoutOptions(newArgs));
+
+		// Wait for new data
+		await waitFor(() => {
+			expect(result.current.data).toBeDefined();
+		});
+
+		// Verify that the query was refetched with new args
+		expect(result.current.data).toBeDefined();
+		expect(result.current.isSuccess).toBe(true);
+	});
+
+	it('should handle disabled query when wallet not connected', async () => {
+		// Mock wallet not connected
+		mockUseAccount.mockReturnValue({
+			address: undefined,
+		} as unknown as ReturnType<typeof useAccount>);
+
+		const { result } = renderHook(() => useCheckoutOptions(defaultArgs));
+
+		// Should not make request when wallet not connected
+		expect(result.current.isLoading).toBe(false);
+		expect(result.current.data).toBeUndefined();
+		expect(result.current.error).toBeNull();
+	});
+
+	it('should handle multiple orders', async () => {
+		const multiOrderArgs: UseCheckoutOptionsParams = {
+			chainId: 137,
+			orders: [
+				{
+					collectionAddress: zeroAddress,
+					orderId: '123',
+					marketplace: MarketplaceKind.sequence_marketplace_v2,
+				},
+				{
+					collectionAddress:
+						'0x1234567890123456789012345678901234567890' as `0x${string}`,
+					orderId: '456',
+					marketplace: MarketplaceKind.opensea,
+				},
+			],
+			additionalFee: 100,
+			query: {},
+		};
+
+		const { result } = renderHook(() => useCheckoutOptions(multiOrderArgs));
+
+		await waitFor(() => {
+			expect(result.current.isLoading).toBe(false);
+		});
+
+		expect(result.current.data).toBeDefined();
+		expect(result.current.error).toBeNull();
+	});
+});

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

@@ -1,17 +1,22 @@
 import { skipToken } from '@tanstack/react-query';
-import { renderHook, waitFor } from '@test';
+import { renderHook, server, waitFor } from '@test';
+import { HttpResponse, http } from 'msw';
 import type { Address } from 'viem';
+import { zeroAddress } from 'viem';
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { useAccount } from 'wagmi';
+import {
+	mockCheckoutOptions,
+	mockMarketplaceEndpoint,
+} from '../../_internal/api/__mocks__/marketplace.msw';
 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 })),
-	};
-});
+// Mock wagmi useAccount hook
+vi.mock('wagmi', () => ({
+	useAccount: vi.fn(),
+}));
+
+const mockUseAccount = vi.mocked(useAccount);
 
 const mockContractAddress =
 	'0x1234567890123456789012345678901234567890' as Address;
@@ -21,6 +26,9 @@ const mockCollectionAddress =
 describe('useCheckoutOptionsSalesContract', () => {
 	beforeEach(() => {
 		vi.clearAllMocks();
+		mockUseAccount.mockReturnValue({
+			address: zeroAddress,
+		} as unknown as ReturnType<typeof useAccount>);
 	});
 
 	afterEach(() => {
@@ -51,15 +59,8 @@ describe('useCheckoutOptionsSalesContract', () => {
 			expect(result.current.isSuccess).toBe(true);
 		});
 
-		// Check the response
-		expect(result.current.data).toEqual({
-			options: {
-				crypto: 'all',
-				swap: [],
-				nftCheckout: [],
-				onRamp: [],
-			},
-		});
+		// Check the response matches our mock
+		expect(result.current.data).toEqual(mockCheckoutOptions);
 	});
 
 	it('should handle skipToken', () => {
@@ -96,8 +97,7 @@ describe('useCheckoutOptionsSalesContract', () => {
 			expect(result.current.isSuccess).toBe(true);
 		});
 
-		expect(result.current.data).toBeDefined();
-		expect(result.current.data?.options).toBeDefined();
+		expect(result.current.data).toEqual(mockCheckoutOptions);
 	});
 
 	it('should refetch when args change', async () => {
@@ -135,23 +135,16 @@ describe('useCheckoutOptionsSalesContract', () => {
 		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>);
+	it('should handle error states', async () => {
+		// Override the handler for this test to return an error
+		server.use(
+			http.post(mockMarketplaceEndpoint('CheckoutOptionsSalesContract'), () => {
+				return HttpResponse.json(
+					{ error: { message: 'Failed to fetch checkout options' } },
+					{ status: 500 },
+				);
+			}),
+		);
 
 		const { result } = renderHook(() =>
 			useCheckoutOptionsSalesContract({
@@ -163,28 +156,17 @@ describe('useCheckoutOptionsSalesContract', () => {
 		);
 
 		await waitFor(() => {
-			expect(result.current.isSuccess).toBe(true);
+			expect(result.current.isError).toBe(true);
 		});
 
-		expect(result.current.data).toBeDefined();
+		expect(result.current.error).toBeDefined();
+		expect(result.current.data).toBeUndefined();
 	});
 
 	it('should handle when wallet is not connected', async () => {
-		const { useAccount } = await import('wagmi');
-		const mockUseAccount = vi.mocked(useAccount);
-
-		// No wallet connected
+		// Mock wallet not connected for this test
 		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(() =>
@@ -196,14 +178,10 @@ describe('useCheckoutOptionsSalesContract', () => {
 			}),
 		);
 
-		// 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();
+		// Should not make request when wallet not connected
+		expect(result.current.isLoading).toBe(false);
+		expect(result.current.data).toBeUndefined();
+		expect(result.current.error).toBeNull();
 	});
 
 	it('should handle empty items array', async () => {
@@ -216,10 +194,9 @@ describe('useCheckoutOptionsSalesContract', () => {
 			}),
 		);
 
-		await waitFor(() => {
-			expect(result.current.isSuccess).toBe(true);
-		});
-
-		expect(result.current.data).toBeDefined();
+		// Should not make request when items array is empty
+		expect(result.current.isLoading).toBe(false);
+		expect(result.current.data).toBeUndefined();
+		expect(result.current.error).toBeNull();
 	});
 });