@0xsequence/marketplace-sdk 0.8.2 → 0.8.4

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

@@ -50,12 +50,18 @@ describe('useGenerateListingTransaction', () => {
 			  [
 			    {
 			      "data": "0x...",
-			      "executeType": "order",
 			      "id": "tokenApproval",
 			      "price": "0",
 			      "to": "0x1234567890123456789012345678901234567890",
 			      "value": "0",
 			    },
+			    {
+			      "data": "0x...",
+			      "id": "createListing",
+			      "price": "0",
+			      "to": "0x1234567890123456789012345678901234567890",
+			      "value": "0",
+			    },
 			  ],
 			  {
 			    "collectionAddress": "0x0000000000000000000000000000000000000000",
@@ -91,12 +97,18 @@ describe('useGenerateListingTransaction', () => {
 			  [
 			    {
 			      "data": "0x...",
-			      "executeType": "order",
 			      "id": "tokenApproval",
 			      "price": "0",
 			      "to": "0x1234567890123456789012345678901234567890",
 			      "value": "0",
 			    },
+			    {
+			      "data": "0x...",
+			      "id": "createListing",
+			      "price": "0",
+			      "to": "0x1234567890123456789012345678901234567890",
+			      "value": "0",
+			    },
 			  ],
 			  {
 			    "collectionAddress": "0x0000000000000000000000000000000000000000",

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

@@ -1,12 +1,19 @@
 import { renderHook, server, waitFor } from '@test';
+import { createMockWallet } from '@test/mocks/wallet';
 import { http, HttpResponse } from 'msw';
 import { zeroAddress } from 'viem';
 import { beforeEach, describe, expect, it, vi } from 'vitest';
-import { mockMarketplaceEndpoint } from '../../_internal/api/__mocks__/marketplace.msw';
+import {
+	createMockSteps,
+	mockMarketplaceEndpoint,
+} from '../../_internal/api/__mocks__/marketplace.msw';
 import {
 	ContractType,
 	OrderbookKind,
+	StepType,
+	WalletKind,
 } from '../../_internal/api/marketplace.gen';
+import * as walletModule from '../../_internal/wallet/useWallet';
 import { useGenerateOfferTransaction } from '../useGenerateOfferTransaction';
 
 describe('useGenerateOfferTransaction', () => {
@@ -44,34 +51,9 @@ describe('useGenerateOfferTransaction', () => {
 
 		await result.current.generateOfferTransactionAsync(mockTransactionProps);
 
-		expect(mockOnSuccess.mock.lastCall).toMatchInlineSnapshot(`
-			[
-			  [
-			    {
-			      "data": "0x...",
-			      "executeType": "order",
-			      "id": "tokenApproval",
-			      "price": "0",
-			      "to": "0x1234567890123456789012345678901234567890",
-			      "value": "0",
-			    },
-			  ],
-			  {
-			    "collectionAddress": "0x0000000000000000000000000000000000000000",
-			    "contractType": "ERC721",
-			    "maker": "0x0000000000000000000000000000000000000000",
-			    "offer": {
-			      "currencyAddress": "0x0000000000000000000000000000000000000000",
-			      "expiry": 2024-12-31T00:00:00.000Z,
-			      "pricePerToken": "1000000000000000000",
-			      "quantity": "1",
-			      "tokenId": "1",
-			    },
-			    "orderbook": "sequence_marketplace_v2",
-			  },
-			  undefined,
-			]
-		`);
+		expect(mockOnSuccess).toHaveBeenCalled();
+		const steps = mockOnSuccess.mock.calls[0]?.[0];
+		expect(steps.length).toBeGreaterThan(0);
 	});
 
 	it('should handle non-async generation with callback', async () => {
@@ -84,34 +66,9 @@ describe('useGenerateOfferTransaction', () => {
 		await waitFor(() => {
 			expect(mockOnSuccess).toHaveBeenCalled();
 		});
-		expect(mockOnSuccess.mock.lastCall).toMatchInlineSnapshot(`
-			[
-			  [
-			    {
-			      "data": "0x...",
-			      "executeType": "order",
-			      "id": "tokenApproval",
-			      "price": "0",
-			      "to": "0x1234567890123456789012345678901234567890",
-			      "value": "0",
-			    },
-			  ],
-			  {
-			    "collectionAddress": "0x0000000000000000000000000000000000000000",
-			    "contractType": "ERC721",
-			    "maker": "0x0000000000000000000000000000000000000000",
-			    "offer": {
-			      "currencyAddress": "0x0000000000000000000000000000000000000000",
-			      "expiry": 2024-12-31T00:00:00.000Z,
-			      "pricePerToken": "1000000000000000000",
-			      "quantity": "1",
-			      "tokenId": "1",
-			    },
-			    "orderbook": "sequence_marketplace_v2",
-			  },
-			  undefined,
-			]
-		`);
+
+		const steps = mockOnSuccess.mock.calls[0]?.[0];
+		expect(steps.length).toBeGreaterThan(0);
 	});
 
 	it('should handle API errors', async () => {
@@ -158,4 +115,105 @@ describe('useGenerateOfferTransaction', () => {
 
 		expect(mockOnSuccess).not.toHaveBeenCalled();
 	});
+
+	describe('wallet-specific behavior', () => {
+		// Create mock wallets for different types
+		const mockSequenceWallet = createMockWallet({
+			walletKind: WalletKind.sequence,
+		});
+
+		const mockNonSequenceWallet = createMockWallet({
+			walletKind: WalletKind.unknown,
+		});
+
+		it('should not include tokenApproval step for Sequence wallet', async () => {
+			// Mock useWallet to return a Sequence wallet
+			const useWalletSpy = vi.spyOn(walletModule, 'useWallet');
+			useWalletSpy.mockReturnValue({
+				wallet: mockSequenceWallet,
+				isLoading: false,
+				isError: false,
+			});
+
+			// Override the default handler to include walletKind in the response
+			server.use(
+				http.post(
+					mockMarketplaceEndpoint('GenerateOfferTransaction'),
+					async ({ request }) => {
+						// Add wallet type to the request payload
+						const reqBody = (await request.json()) as Record<string, unknown>;
+						reqBody.walletType = WalletKind.sequence;
+
+						// For Sequence wallet - only return createOffer step
+						return HttpResponse.json({
+							steps: createMockSteps([StepType.createOffer]),
+						});
+					},
+				),
+			);
+
+			const { result } = renderHook(() =>
+				useGenerateOfferTransaction(defaultArgs),
+			);
+
+			await result.current.generateOfferTransactionAsync(mockTransactionProps);
+
+			expect(mockOnSuccess).toHaveBeenCalled();
+			const steps = mockOnSuccess.mock.calls[0]?.[0];
+
+			// Verify there is only one step: createOffer (no tokenApproval)
+			expect(steps).toHaveLength(1);
+			expect(steps[0].id).toBe('createOffer');
+
+			// Restore the original useWallet implementation
+			useWalletSpy.mockRestore();
+		});
+
+		it('should include tokenApproval step for non-Sequence wallet', async () => {
+			// Mock useWallet to return a non-Sequence wallet
+			const useWalletSpy = vi.spyOn(walletModule, 'useWallet');
+			useWalletSpy.mockReturnValue({
+				wallet: mockNonSequenceWallet,
+				isLoading: false,
+				isError: false,
+			});
+
+			// Override the default handler to include walletKind in the response
+			server.use(
+				http.post(
+					mockMarketplaceEndpoint('GenerateOfferTransaction'),
+					async ({ request }) => {
+						// Add wallet type to the request payload
+						const reqBody = (await request.json()) as Record<string, unknown>;
+						reqBody.walletType = WalletKind.unknown;
+
+						// For non-Sequence wallet - return tokenApproval and createOffer steps
+						return HttpResponse.json({
+							steps: createMockSteps([
+								StepType.tokenApproval,
+								StepType.createOffer,
+							]),
+						});
+					},
+				),
+			);
+
+			const { result } = renderHook(() =>
+				useGenerateOfferTransaction(defaultArgs),
+			);
+
+			await result.current.generateOfferTransactionAsync(mockTransactionProps);
+
+			expect(mockOnSuccess).toHaveBeenCalled();
+			const steps = mockOnSuccess.mock.calls[0]?.[0];
+
+			// Verify there are two steps: tokenApproval and createOffer
+			expect(steps).toHaveLength(2);
+			expect(steps[0].id).toBe('tokenApproval');
+			expect(steps[1].id).toBe('createOffer');
+
+			// Restore the original useWallet implementation
+			useWalletSpy.mockRestore();
+		});
+	});
 });

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

@@ -3,13 +3,14 @@ import { http, HttpResponse } from 'msw';
 import { zeroAddress } from 'viem';
 import { beforeEach, describe, expect, it, vi } from 'vitest';
 import {
+	createMockSteps,
 	mockMarketplaceEndpoint,
-	mockSteps,
 } from '../../_internal/api/__mocks__/marketplace.msw';
 import {
 	ContractType,
 	MarketplaceKind,
 	OrderbookKind,
+	StepType,
 } from '../../_internal/api/marketplace.gen';
 import { useGenerateSellTransaction } from '../useGenerateSellTransaction';
 
@@ -52,12 +53,18 @@ describe('useGenerateSellTransaction', () => {
 			  [
 			    {
 			      "data": "0x...",
-			      "executeType": "order",
 			      "id": "tokenApproval",
 			      "price": "0",
 			      "to": "0x1234567890123456789012345678901234567890",
 			      "value": "0",
 			    },
+			    {
+			      "data": "0x...",
+			      "id": "sell",
+			      "price": "0",
+			      "to": "0x1234567890123456789012345678901234567890",
+			      "value": "0",
+			    },
 			  ],
 			  {
 			    "additionalFees": [],
@@ -87,7 +94,7 @@ describe('useGenerateSellTransaction', () => {
 
 		await waitFor(() => {
 			expect(mockOnSuccess).toHaveBeenCalledWith(
-				mockSteps,
+				createMockSteps([StepType.tokenApproval, StepType.sell]),
 				mockTransactionProps,
 				undefined,
 			);

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

@@ -0,0 +1,294 @@
+import { renderHook, server, waitFor } from '@test';
+import { http, HttpResponse } from 'msw';
+import { zeroAddress } from 'viem';
+import { beforeEach, describe, expect, it } from 'vitest';
+import {
+	mockIndexerEndpoint,
+	mockTokenBalance,
+} from '../../_internal/api/__mocks__/indexer.msw';
+import {
+	mockCollectibleOrder,
+	mockMarketplaceEndpoint,
+} from '../../_internal/api/__mocks__/marketplace.msw';
+import type { UseInventoryArgs } from '../../queries/inventory';
+import { mockConfig } from '../options/__mocks__/marketplaceConfig.msw';
+import { useInventory } from '../useInventory';
+
+// Make sure mockCollectibleOrder has a tokenId of "1" for tests
+mockCollectibleOrder.metadata.tokenId = '1';
+
+describe('useInventory', () => {
+	const defaultArgs: UseInventoryArgs = {
+		accountAddress:
+			'0x1234567890123456789012345678901234567890' as `0x${string}`,
+		chainId: 1,
+		collectionAddress: zeroAddress,
+	};
+
+	beforeEach(() => {
+		// Reset MSW handlers before each test to ensure a clean state
+		server.resetHandlers();
+	});
+
+	it('should fetch inventory data successfully', async () => {
+		const { result } = renderHook(() => useInventory(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 is defined and has pages
+		expect(result.current.data).toBeDefined();
+		expect(result.current.data?.pages).toBeDefined();
+		expect(result.current.error).toBeNull();
+	});
+
+	it('should handle error gracefully', async () => {
+		// Mock both API endpoints to return errors
+		server.use(
+			http.post(mockMarketplaceEndpoint('ListCollectibles'), () => {
+				return new HttpResponse(null, { status: 500 });
+			}),
+			http.post(mockIndexerEndpoint('GetTokenBalances'), () => {
+				return new HttpResponse(null, { status: 500 });
+			}),
+		);
+
+		const { result } = renderHook(() =>
+			useInventory({
+				...defaultArgs,
+				// Add a unique key to avoid caching
+				collectionAddress:
+					'0xdeadbeef0000000000000000000000000000dead' as `0x${string}`,
+			}),
+		);
+
+		// Wait for the query to finish loading and show error
+		await waitFor(
+			() => {
+				expect(result.current.isLoading).toBe(false);
+			},
+			{ timeout: 3000 },
+		);
+
+		// Verify error state
+		expect(result.current.status).toBe('error');
+		expect(result.current.isError).toBe(true);
+		expect(result.current.error).not.toBeNull();
+	});
+
+	it('should refetch when args change', async () => {
+		const { result, rerender } = renderHook(() => useInventory(defaultArgs));
+
+		// Wait for initial data
+		await waitFor(() => {
+			expect(result.current.isLoading).toBe(false);
+		});
+
+		// Change args and rerender with a new hook
+		const newArgs = {
+			...defaultArgs,
+			collectionAddress:
+				'0x1234567890123456789012345678901234567890' as `0x${string}`,
+		};
+
+		rerender(() => useInventory(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 queries', async () => {
+		const disabledArgs: UseInventoryArgs = {
+			...defaultArgs,
+			query: {
+				enabled: false,
+			},
+		};
+
+		const { result } = renderHook(() => useInventory(disabledArgs));
+
+		// Should not be loading or have data
+		expect(result.current.isLoading).toBe(false);
+		expect(result.current.data).toBeUndefined();
+		expect(result.current.isFetched).toBe(false);
+	});
+
+	it('should use isLaos721 flag from marketplaceConfig', async () => {
+		// Setup config with LAOS collection
+		const laosCollectionAddress = '0x1234567890123456789012345678901234567890';
+		server.use(
+			http.get('*/marketplace/*/settings.json', () => {
+				const configWithLaos = {
+					...mockConfig,
+					collections: [
+						{
+							...mockConfig.collections[0],
+							address: laosCollectionAddress,
+							isLAOSERC721: true,
+						},
+					],
+				};
+				return HttpResponse.json(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(
+			http.post(mockMarketplaceEndpoint('ListCollectibles'), () => {
+				return HttpResponse.json({
+					collectibles: [],
+					page: {
+						page: 1,
+						pageSize: 50,
+						more: false,
+					},
+				});
+			}),
+			// Mock indexer with data
+			http.post(mockIndexerEndpoint('GetTokenBalances'), () => {
+				return HttpResponse.json({
+					balances: [mockTokenBalance],
+					page: {
+						page: 1,
+						pageSize: 50,
+						more: false,
+					},
+				});
+			}),
+		);
+
+		const { result } = renderHook(() => useInventory(defaultArgs));
+
+		await waitFor(() => {
+			expect(result.current.isLoading).toBe(false);
+		});
+
+		expect(result.current.data).toBeDefined();
+		expect(result.current.data?.pages[0].collectibles).toBeDefined();
+		expect(result.current.isSuccess).toBe(true);
+	});
+
+	it('should support pagination with fetchNextPage', async () => {
+		// Simplified test for pagination
+		// Set up mock data for first and second pages
+		const page1Data = {
+			collectibles: [
+				{
+					...mockCollectibleOrder,
+					metadata: {
+						...mockCollectibleOrder.metadata,
+						tokenId: '1',
+						name: 'Token 1',
+					},
+				},
+			],
+			page: {
+				page: 1,
+				pageSize: 10,
+				more: true, // indicate there's a next page
+			},
+		};
+
+		// Mock API to return data for the first page
+		server.use(
+			http.post(
+				mockMarketplaceEndpoint('ListCollectibles'),
+				async ({ request }) => {
+					const body = (await request.json()) as { page?: number };
+					const pageNumber = body?.page || 1;
+
+					// Return first page data
+					if (pageNumber === 1) {
+						return HttpResponse.json(page1Data);
+					}
+
+					// For second page, return empty collectibles but with more=false
+					return HttpResponse.json({
+						collectibles: [],
+						page: {
+							page: 2,
+							pageSize: 10,
+							more: false,
+						},
+					});
+				},
+			),
+		);
+
+		// Use unique test args to avoid caching issues
+		const testArgs = {
+			...defaultArgs,
+			accountAddress:
+				'0xabcdef1234567890abcdef1234567890abcdef12' as `0x${string}`,
+			collectionAddress:
+				'0xabcdef1234567890abcdef1234567890abcdef12' as `0x${string}`,
+		};
+
+		const { result } = renderHook(() => useInventory(testArgs));
+
+		// Wait for the first page to load
+		await waitFor(
+			() => {
+				expect(result.current.isLoading).toBe(false);
+				expect(result.current.data?.pages).toBeDefined();
+			},
+			{ timeout: 5000 },
+		);
+
+		// Verify first page data loaded correctly
+		expect(result.current.data?.pages[0].collectibles).toBeDefined();
+		expect(result.current.data?.pages[0].collectibles.length).toBeGreaterThan(
+			0,
+		);
+		// Check that at least one item has the expected tokenId
+		expect(
+			result.current.data?.pages[0].collectibles.some(
+				(c) => c.metadata.tokenId === '1',
+			),
+		).toBe(true);
+		expect(result.current.hasNextPage).toBe(true);
+
+		// Fetch the next page
+		await result.current.fetchNextPage();
+
+		// Wait for second page to load
+		await waitFor(
+			() => {
+				expect(result.current.data?.pages.length).toBe(2);
+			},
+			{ timeout: 5000 },
+		);
+
+		// For an empty second page we just verify it exists
+		expect(result.current.data?.pages[1]).toBeDefined();
+		expect(result.current.hasNextPage).toBe(false); // No more pages
+	});
+});

package/src/react/hooks/index.ts

@@ -12,6 +12,7 @@ export * from './useCurrency';
 export * from './useFilters';
 export * from './useFloorOrder';
 export * from './useHighestOffer';
+export * from './useInventory';
 export * from './useListBalances';
 export * from './useListCollectibleActivities';
 export * from './useListCollectibles';

package/src/react/hooks/useAutoSelectFeeOption.tsx

@@ -1,7 +1,7 @@
 import { type Address, zeroAddress } from 'viem';
 
 import { useChain } from '@0xsequence/connect';
-import { useCallback } from 'react';
+import { useCallback, useEffect } from 'react';
 import { useAccount } from 'wagmi';
 import type { FeeOption } from '../../types/waas-types';
 import { useCollectionBalanceDetails } from './useCollectionBalanceDetails';
@@ -19,6 +19,7 @@ type UseAutoSelectFeeOptionArgs = {
 		options: FeeOption[] | undefined;
 		chainId: number;
 	};
+	enabled?: boolean;
 };
 
 /**
@@ -87,6 +88,7 @@ type UseAutoSelectFeeOptionArgs = {
  */
 export function useAutoSelectFeeOption({
 	pendingFeeOptionConfirmation,
+	enabled,
 }: UseAutoSelectFeeOptionArgs) {
 	const { address: userAddress } = useAccount();
 
@@ -110,7 +112,8 @@ export function useAutoSelectFeeOption({
 			omitNativeBalances: false,
 		},
 		query: {
-			enabled: !!pendingFeeOptionConfirmation.options && !!userAddress,
+			enabled:
+				!!pendingFeeOptionConfirmation.options && !!userAddress && enabled,
 		},
 	});
 	const chain = useChain(pendingFeeOptionConfirmation.chainId);
@@ -131,7 +134,11 @@ export function useAutoSelectFeeOption({
 		})),
 	];
 
-	console.debug('currency balances', combinedBalances);
+	useEffect(() => {
+		if (combinedBalances) {
+			console.debug('currency balances', combinedBalances);
+		}
+	}, [combinedBalances]);
 
 	const autoSelectedOption = useCallback(async () => {
 		if (!userAddress) {

package/src/react/hooks/useCancelOrder.tsx

@@ -54,6 +54,7 @@ export const useCancelOrder = ({
 					options: undefined,
 					chainId,
 				},
+		enabled: !!pendingFeeOptionConfirmation,
 	});
 
 	useEffect(() => {