@0xsequence/marketplace-sdk 0.5.2 → 0.5.4

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

@@ -0,0 +1,148 @@
+import { describe, expect, it } from 'vitest';
+import { useLowestListing } from '../useLowestListing';
+import { renderHook, waitFor } from '../../_internal/test-utils';
+import { zeroAddress } from 'viem';
+import { MarketplaceKind } from '../../_internal/api/marketplace.gen';
+import { http, HttpResponse } from 'msw';
+import {
+	mockOrder,
+	mockMarketplaceEndpoint,
+} from '../../_internal/api/__mocks__/marketplace.msw';
+import { server } from '../../_internal/test/setup';
+
+describe('useLowestListing', () => {
+	const defaultArgs = {
+		chainId: '1',
+		collectionAddress: zeroAddress as `0x${string}`,
+		tokenId: '1',
+		query: {},
+	};
+
+	it('should fetch lowest listing data successfully', async () => {
+		const { result } = renderHook(() => useLowestListing(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).toBeDefined();
+		expect(result.current.data?.order).toEqual(mockOrder);
+		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('GetCollectibleLowestListing'), () => {
+				return HttpResponse.json(
+					{ error: { message: 'Failed to fetch lowest listing' } },
+					{ status: 500 },
+				);
+			}),
+		);
+
+		const { result } = renderHook(() => useLowestListing(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(() =>
+			useLowestListing(defaultArgs),
+		);
+
+		// Wait for initial data
+		await waitFor(() => {
+			expect(result.current.isLoading).toBe(false);
+		});
+
+		// Change args and rerender
+		const newArgs = {
+			...defaultArgs,
+			collectionAddress:
+				'0x1234567890123456789012345678901234567890' as `0x${string}`,
+			tokenId: '2',
+		};
+
+		rerender(() => useLowestListing(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?.order).toEqual(mockOrder);
+		expect(result.current.isSuccess).toBe(true);
+	});
+
+	it('should handle optional filter parameter', async () => {
+		const argsWithFilter = {
+			...defaultArgs,
+			filters: {
+				marketplace: [
+					MarketplaceKind.sequence_marketplace_v2,
+				] as MarketplaceKind[],
+				currencies: [zeroAddress] as string[],
+			},
+		};
+
+		const { result } = renderHook(() => useLowestListing(argsWithFilter));
+
+		await waitFor(() => {
+			expect(result.current.isLoading).toBe(false);
+		});
+
+		expect(result.current.data?.order).toEqual(mockOrder);
+		expect(result.current.isSuccess).toBe(true);
+	});
+
+	it('should handle query options', async () => {
+		const argsWithQuery = {
+			...defaultArgs,
+			query: {
+				enabled: true,
+				staleTime: 5000,
+				cacheTime: 10000,
+			},
+		};
+
+		const { result } = renderHook(() => useLowestListing(argsWithQuery));
+
+		await waitFor(() => {
+			expect(result.current.isLoading).toBe(false);
+		});
+
+		expect(result.current.data?.order).toEqual(mockOrder);
+		expect(result.current.isSuccess).toBe(true);
+	});
+
+	it('should handle disabled query', async () => {
+		const argsWithDisabledQuery = {
+			...defaultArgs,
+			query: {
+				enabled: false,
+			},
+		};
+
+		const { result } = renderHook(() =>
+			useLowestListing(argsWithDisabledQuery),
+		);
+
+		// Should not be loading since query is disabled
+		expect(result.current.isLoading).toBe(false);
+		expect(result.current.data).toBeUndefined();
+		expect(result.current.isSuccess).toBe(false);
+	});
+});

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

@@ -0,0 +1,106 @@
+import { describe, expect, it, beforeEach } from 'vitest';
+import { useMarketplaceConfig } from '../useMarketplaceConfig';
+import { renderHook, waitFor } from '../../_internal/test-utils';
+import {
+	mockConfig,
+	mockStyles,
+	createConfigHandler,
+	createStylesHandler,
+	createErrorHandler,
+	createStylesErrorHandler,
+} from '../options/__mocks__/marketplaceConfig.msw';
+import { server } from '../../_internal/test/setup';
+
+describe('useMarketplaceConfig', () => {
+	beforeEach(() => {
+		// Reset handlers before each test
+		server.resetHandlers();
+		// Set up default handlers
+		server.use(createConfigHandler(), createStylesHandler());
+	});
+
+	it('should fetch marketplace config and styles successfully', async () => {
+		const { result } = renderHook(() => useMarketplaceConfig());
+
+		// 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).toBeDefined();
+		expect(result.current.data).toEqual({
+			...mockConfig,
+			cssString: mockStyles.replaceAll(/['"]/g, ''),
+			manifestUrl: expect.stringContaining('/manifest.json'),
+		});
+		expect(result.current.error).toBeNull();
+	});
+
+	it('should handle config fetch error', async () => {
+		// Override the handler for this test to return an error
+		server.use(createErrorHandler());
+
+		const { result } = renderHook(() => useMarketplaceConfig());
+
+		await waitFor(() => {
+			expect(result.current.isError).toBe(true);
+		});
+
+		expect(result.current.error).toBeDefined();
+		expect(result.current.data).toBeUndefined();
+	});
+
+	it('should handle styles fetch error', async () => {
+		// Override the handler for this test to return an error
+		server.use(createStylesErrorHandler(), createConfigHandler());
+
+		const { result } = renderHook(() => useMarketplaceConfig());
+
+		await waitFor(() => {
+			expect(result.current.data).toBeDefined();
+		});
+
+		// They just result in an empty cssString
+		expect(result.current.isError).toBe(false);
+		expect(result.current.data?.cssString).toBe('');
+	});
+
+	it('should handle both config and styles fetch errors', async () => {
+		// Override both handlers to return errors
+		server.use(createErrorHandler(), createStylesErrorHandler());
+
+		const { result } = renderHook(() => useMarketplaceConfig());
+
+		await waitFor(() => {
+			expect(result.current.isError).toBe(true);
+		});
+
+		expect(result.current.error).toBeDefined();
+		expect(result.current.data).toBeUndefined();
+	});
+
+	it('should cache the config data', async () => {
+		// First render to populate cache
+		const { result, rerender } = renderHook(() => useMarketplaceConfig());
+
+		await waitFor(() => {
+			expect(result.current.isLoading).toBe(false);
+		});
+
+		// Trigger a rerender
+		rerender();
+
+		// Should have data immediately from cache
+		expect(result.current.isLoading).toBe(false);
+		expect(result.current.data).toEqual({
+			...mockConfig,
+			cssString: mockStyles.replaceAll(/['"]/g, ''),
+			manifestUrl: expect.stringContaining('/manifest.json'),
+		});
+	});
+});

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

@@ -0,0 +1,129 @@
+import { describe, expect, it, vi, beforeEach } from 'vitest';
+import type { Mock } from 'vitest';
+import { useRoyaltyPercentage } from '../useRoyaltyPercentage';
+import { renderHook, waitFor } from '../../_internal/test-utils';
+import {
+	createMockPublicClient,
+	type MockPublicClient,
+} from '../../_internal/test/mocks/publicClient';
+import { getPublicRpcClient } from '../../../utils/get-public-rpc-client';
+
+// Mock the getPublicRpcClient
+vi.mock('../../../utils/get-public-rpc-client');
+
+describe('useRoyaltyPercentage', () => {
+	const mockAddress = '0x1234567890123456789012345678901234567890' as const;
+	const mockArgs = {
+		chainId: '1',
+		collectionAddress: mockAddress,
+		collectibleId: '1',
+		query: {},
+	};
+
+	const mockRoyaltyAmount = 500n; // 5% royalty
+
+	beforeEach(() => {
+		// Reset all mocks before each test
+		vi.resetAllMocks();
+
+		// Create a mock public client with custom royaltyInfo implementation
+		const mockPublicClient = createMockPublicClient({
+			readContract: vi.fn().mockImplementation(async ({ functionName }) => {
+				if (functionName === 'royaltyInfo') {
+					return [
+						mockAddress, // receiver address
+						mockRoyaltyAmount, // royalty amount
+					];
+				}
+				return [0n, 0n];
+			}),
+		});
+
+		// Mock the getPublicRpcClient to return our mock client
+		(getPublicRpcClient as Mock).mockReturnValue(mockPublicClient);
+	});
+
+	it('should fetch royalty percentage successfully', async () => {
+		const { result } = renderHook(() => useRoyaltyPercentage(mockArgs));
+
+		// 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).toBeDefined();
+		expect(result.current.data).toBe(mockRoyaltyAmount);
+		expect(result.current.error).toBeNull();
+	});
+
+	it('should handle contract read error gracefully', async () => {
+		// Override the mock to simulate a contract read error
+		const mockPublicClient = createMockPublicClient({
+			readContract: vi
+				.fn()
+				.mockRejectedValue(new Error('Contract read failed')),
+		});
+		(getPublicRpcClient as Mock).mockReturnValue(mockPublicClient);
+
+		const { result } = renderHook(() => useRoyaltyPercentage(mockArgs));
+
+		await waitFor(() => {
+			expect(result.current.isLoading).toBe(false);
+		});
+
+		// Should return 0 as specified in the hook implementation
+		expect(result.current.data).toBe(0n);
+		expect(result.current.isError).toBe(false);
+	});
+
+	it('should validate input parameters', async () => {
+		// Using undefined as an invalid chain ID - this will fail Zod's string coercion
+		const invalidArgs = {
+			...mockArgs,
+			chainId: undefined,
+		};
+
+		// @ts-expect-error - invalid args
+		const { result } = renderHook(() => useRoyaltyPercentage(invalidArgs));
+
+		// Wait for the query to complete
+		await waitFor(() => {
+			expect(result.current.isLoading).toBe(false);
+		});
+
+		// The query should fail with a validation error
+		expect(result.current.isError).toBe(true);
+		expect(result.current.error).toBeDefined();
+	});
+
+	it('should cache the royalty data', async () => {
+		const { result, rerender } = renderHook(() =>
+			useRoyaltyPercentage(mockArgs),
+		);
+
+		await waitFor(() => {
+			expect(result.current.isLoading).toBe(false);
+		});
+
+		const mockClient = getPublicRpcClient('1') as MockPublicClient;
+		const mockReadContract = mockClient.readContract as Mock;
+		// Record the number of calls to readContract
+		const initialCalls = mockReadContract.mock.calls.length;
+
+		// Trigger a rerender
+		rerender();
+
+		// Should have data immediately from cache
+		expect(result.current.isLoading).toBe(false);
+		expect(result.current.data).toBe(mockRoyaltyAmount);
+
+		// Verify no additional contract calls were made
+		const finalCalls = mockReadContract.mock.calls.length;
+		expect(finalCalls).toBe(initialCalls);
+	});
+});

package/src/react/hooks/index.ts

@@ -6,7 +6,6 @@ export * from './useCollection';
 export * from './useCollectionBalanceDetails';
 export * from './useConfig';
 export * from './useCurrencies';
-export * from './useCurrencyOptions';
 export * from './useCurrency';
 export * from './useFilters';
 export * from './useFloorOrder';
@@ -14,6 +13,7 @@ export * from './useHighestOffer';
 export * from './useListBalances';
 export * from './useListCollectibleActivities';
 export * from './useListCollectibles';
+export * from './useListCollectiblesPaginated';
 export * from './useListCollectionActivities';
 export * from './useListOffersForCollectible';
 export * from './useCountOffersForCollectible';

package/src/react/hooks/options/__mocks__/marketplaceConfig.msw.ts

@@ -1,30 +1,86 @@
 import { http, HttpResponse } from 'msw';
-import { WalletOptions, type MarketplaceConfig } from '../../../../types';
+import {
+	MarketplaceType,
+	MarketplaceWallet,
+	OrderbookKind,
+	type MarketplaceConfig,
+	FilterCondition,
+} from '../../../../types';
 import { mockCurrencies } from '../../../_internal/api/__mocks__/marketplace.msw';
+import { zeroAddress } from 'viem';
 
 // Mock data
 export const mockConfig: MarketplaceConfig = {
-	projectId: 123,
 	publisherId: 'test-publisher',
 	title: 'Test Marketplace',
 	shortDescription: 'A test marketplace',
+	socials: {
+		twitter: 'https://twitter.com/test',
+		discord: 'https://discord.com/test',
+		instagram: 'https://instagram.com/test',
+		website: '',
+		tiktok: '',
+		youtube: '',
+	},
 	faviconUrl: 'https://example.com/favicon.png',
 	landingBannerUrl: 'https://example.com/banner.png',
 	logoUrl: 'https://example.com/logo.png',
-	titleTemplate: '%s | Test Marketplace',
-	walletOptions: [WalletOptions.Sequence],
+	walletOptions: {
+		walletType: MarketplaceWallet.UNIVERSAL,
+		oidcIssuers: {},
+		connectors: ['coinbase', 'walletconnect'],
+		includeEIP6963Wallets: true,
+	},
 	collections: [
 		{
-			collectionAddress: '0x1234567890123456789012345678901234567890',
+			address: zeroAddress,
 			chainId: 1,
-			marketplaceFeePercentage: 2.5,
-			marketplaceType: 'orderbook',
+			marketplaceType: MarketplaceType.ORDERBOOK,
 			currencyOptions: mockCurrencies.map((c) => c.contractAddress),
+			exchanges: [],
+			bannerUrl: '',
+			feePercentage: 3.5,
+			destinationMarketplace: OrderbookKind.sequence_marketplace_v2,
+			filterSettings: {
+				filterOrder: ['Type', 'Rarity'],
+				exclusions: [
+					{
+						key: 'Type',
+						condition: FilterCondition.SPECIFIC_VALUE,
+						value: 'Sample',
+					},
+				],
+			},
+		},
+		{
+			address: '0x1234567890123456789012345678901234567890',
+			chainId: 137,
+			marketplaceType: MarketplaceType.ORDERBOOK,
+			currencyOptions: [mockCurrencies[0].contractAddress],
+			exchanges: [],
+			bannerUrl: 'https://example.com/collection-banner.png',
+			feePercentage: 2.5,
+			destinationMarketplace: OrderbookKind.opensea,
+			filterSettings: {
+				filterOrder: ['Category', 'Level', 'Element'],
+				exclusions: [
+					{
+						key: 'Category',
+						condition: FilterCondition.ENTIRE_KEY,
+					},
+					{
+						key: 'Level',
+						condition: FilterCondition.SPECIFIC_VALUE,
+						value: 'Legendary',
+					},
+				],
+			},
 		},
 	],
 	landingPageLayout: 'default',
 	cssString: '',
 	manifestUrl: '',
+	bannerUrl: '',
 };
 
 export const mockStyles = `
@@ -54,9 +110,9 @@ const debugLog = (endpoint: string, request: Request, response: Response) => {
 
 // MSW handlers
 export const createConfigHandler = (config = mockConfig) =>
-	http.get('*/marketplace/*/config.json', ({ request }) => {
+	http.get('*/marketplace/*/settings.json', ({ request }) => {
 		const response = HttpResponse.json(config);
-		debugLog('config.json', request, response);
+		debugLog('settings.json', request, response);
 		return response;
 	});
 
@@ -70,7 +126,7 @@ export const createStylesHandler = (styles = mockStyles) =>
 	});
 
 export const createErrorHandler = () =>
-	http.get('*/marketplace/*/config.json', () => {
+	http.get('*/marketplace/*/settings.json', () => {
 		return HttpResponse.json(
 			{ code: 3000, msg: 'Project not found' },
 			{ status: 404 },

package/src/react/hooks/options/__tests__/marketplaceConfigOptions.test.tsx

@@ -1,27 +1,18 @@
-import { describe, it, expect, beforeAll, afterAll, afterEach } from 'vitest';
-import { setupServer } from 'msw/node';
+import { describe, it, expect } from 'vitest';
 import { marketplaceConfigOptions } from '../marketplaceConfigOptions';
 import { renderHook, waitFor } from '../../../_internal/test-utils';
 import type { QueryFunctionContext } from '@tanstack/react-query';
 import {
-	handlers,
 	createErrorHandler,
 	createStylesErrorHandler,
 	mockConfig,
 	mockStyles,
 } from '../__mocks__/marketplaceConfig.msw';
+import { server } from '../../../_internal/test/setup';
 
 type MarketplaceConfigQueryKey = ['configs', 'marketplace', string, string];
 type MarketplaceConfigContext = QueryFunctionContext<MarketplaceConfigQueryKey>;
 
-// Create MSW server with default handlers
-const server = setupServer(...handlers);
-
-// Setup test environment
-beforeAll(() => server.listen());
-afterEach(() => server.resetHandlers());
-afterAll(() => server.close());
-
 describe('marketplaceConfigOptions', () => {
 	it('should fetch marketplace config and styles successfully', async () => {
 		const { result } = renderHook(() =>

package/src/react/hooks/options/marketplaceConfigOptions.ts

@@ -1,5 +1,10 @@
 import { queryOptions } from '@tanstack/react-query';
-import type { Env, MarketplaceConfig, SdkConfig } from '../../../types';
+import type {
+	Env,
+	MarketplaceConfig,
+	MarketplaceSettings,
+	SdkConfig,
+} from '../../../types';
 import {
 	MarketplaceConfigFetchError,
 	ProjectNotFoundError,
@@ -8,7 +13,7 @@ import { builderMarketplaceApi, configKeys } from '../../_internal';
 
 const fetchBuilderConfig = async (projectId: string, env: Env) => {
 	const url = `${builderMarketplaceApi(projectId, env)}`;
-	const response = await fetch(`${url}/config.json`);
+	const response = await fetch(`${url}/settings.json`);
 
 	const json = await response.json();
 	if (!response.ok) {
@@ -22,7 +27,7 @@ const fetchBuilderConfig = async (projectId: string, env: Env) => {
 				throw new MarketplaceConfigFetchError(json.msg);
 		}
 	}
-	return json as MarketplaceConfig;
+	return json as MarketplaceSettings;
 };
 
 const fetchStyles = async (projectId: string, env: Env) => {

package/src/react/hooks/useAutoSelectFeeOption.tsx

@@ -1,8 +1,9 @@
-import { zeroAddress, type Address } from 'viem';
+import { type Address, zeroAddress } from 'viem';
+
+import { useChain } from '@0xsequence/kit';
+import { useCallback } from 'react';
 import { useAccount } from 'wagmi';
 import type { FeeOption } from '../ui/modals/_internal/components/waasFeeOptionsSelect/WaasFeeOptionsSelect';
-import { useCallback } from 'react';
-import { useChain } from '@0xsequence/kit';
 import { useCollectionBalanceDetails } from './useCollectionBalanceDetails';
 
 enum AutoSelectFeeOptionError {

package/src/react/hooks/useCancelTransactionSteps.tsx

@@ -10,14 +10,17 @@ import { useWallet } from '../_internal/wallet/useWallet';
 import type { ModalCallbacks } from '../ui/modals/_internal/types';
 import { useConfig } from './useConfig';
 import { useGenerateCancelTransaction } from './useGenerateCancelTransaction';
-import type { TransactionStep } from './useCancelOrder';
-import type { SignatureStep } from '../_internal/utils';
+import type {
+	SignatureStep,
+	TransactionStep as walletTransactionStep,
+} from '../_internal/utils';
 import type { Hex } from 'viem';
 import { useSwitchChainModal } from '../ui/modals/_internal/components/switchChainModal';
 import {
 	ChainSwitchUserRejectedError,
 	WalletInstanceNotFoundError,
 } from '../../utils/_internal/error/transaction';
+import type { TransactionStep } from './useCancelOrder';
 
 interface UseCancelTransactionStepsArgs {
 	collectionAddress: string;
@@ -46,10 +49,10 @@ export const useCancelTransactionSteps = ({
 	});
 
 	const getWalletChainId = async () => {
-		return await wallet!.getChainId();
+		return await wallet?.getChainId();
 	};
 	const switchChain = async () => {
-		await wallet!.switchChain(Number(chainId));
+		await wallet?.switchChain(Number(chainId));
 	};
 	const checkAndSwitchChain = async () => {
 		const walletChainId = await getWalletChainId();
@@ -82,7 +85,11 @@ export const useCancelTransactionSteps = ({
 		marketplace: MarketplaceKind;
 	}) => {
 		try {
-			const address = await wallet!.address();
+			const address = await wallet?.address();
+
+			if (!address) {
+				throw new Error('Wallet address not found');
+			}
 
 			const steps = await generateCancelTransactionAsync({
 				collectionAddress,
@@ -139,7 +146,8 @@ export const useCancelTransactionSteps = ({
 				throw new Error('No transaction or signature step found');
 			}
 
-			let hash: Hex | undefined, reservoirOrderId: string | undefined;
+			let hash: Hex | undefined;
+			let reservoirOrderId: string | undefined;
 
 			if (transactionStep && wallet) {
 				hash = await executeTransaction({ transactionStep });
@@ -191,9 +199,9 @@ export const useCancelTransactionSteps = ({
 	}: {
 		transactionStep: Step;
 	}): Promise<Hex | undefined> => {
-		const hash = await wallet!.handleSendTransactionStep(
+		const hash = await wallet?.handleSendTransactionStep(
 			Number(chainId),
-			transactionStep as any,
+			transactionStep as walletTransactionStep,
 		);
 
 		return hash;
@@ -204,7 +212,7 @@ export const useCancelTransactionSteps = ({
 	}: {
 		signatureStep: Step;
 	}) => {
-		const signature = await wallet!.handleSignMessageStep(
+		const signature = await wallet?.handleSignMessageStep(
 			signatureStep as SignatureStep,
 		);
 

package/src/react/hooks/useCollectionDetailsPolling.tsx

@@ -41,7 +41,7 @@ export const collectionDetailsPollingOptions = (
 			}
 
 			const interval = Math.min(
-				INITIAL_POLLING_INTERVAL * Math.pow(1.5, currentAttempt),
+				INITIAL_POLLING_INTERVAL * 1.5 ** currentAttempt,
 				MAX_POLLING_INTERVAL,
 			);