@0xsequence/marketplace-sdk 0.8.11 → 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__/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

@@ -2,11 +2,6 @@ import { renderHook, server, waitFor } from '@test';
 import { http, HttpResponse } from 'msw';
 import { type Address, zeroAddress } from 'viem';
 import { beforeEach, describe, expect, it } from 'vitest';
-import { ContractType } from '../../_internal';
-import {
-	createLookupMarketplaceHandler,
-	mockConfig,
-} from '../../_internal/api/__mocks__/builder.msw';
 import {
 	mockIndexerEndpoint,
 	mockTokenBalance,
@@ -15,7 +10,6 @@ import {
 	mockCollectibleOrder,
 	mockMarketplaceEndpoint,
 } from '../../_internal/api/__mocks__/marketplace.msw';
-import type { LookupMarketplaceReturn } from '../../_internal/api/builder.gen';
 import type { UseInventoryArgs } from '../../queries/inventory';
 import { useInventory } from '../useInventory';
 
@@ -129,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,
-			marketCollections: [
-				{
-					...mockConfig.marketCollections[0],
-					itemsAddress: laosCollectionAddress,
-					contractType: ContractType.LAOSERC721,
-				},
-			],
-		} satisfies LookupMarketplaceReturn;
-		server.use(createLookupMarketplaceHandler(configWithLaos));
-
-		const laosArgs: UseInventoryArgs = {
-			...defaultArgs,
-			collectionAddress: laosCollectionAddress as Address,
-		};
-
-		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(

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

@@ -39,7 +39,7 @@ describe('useListCollections', () => {
 			expect(result.current.data).toBeDefined();
 		});
 
-		expect(result.current.data).toEqual([]);
+		expect(result.current.data).toMatchSnapshot();
 		expect(result.current.error).toBeNull();
 	});
 

package/src/react/hooks/index.ts

@@ -32,9 +32,16 @@ export * from './useGenerateSellTransaction';
 export * from './useGenerateCancelTransaction';
 export * from './useTransferTokens';
 export * from './useCheckoutOptions';
+export * from './useCheckoutOptionsSalesContract';
 export * from './useListCollections';
 export * from './useCancelOrder';
 export * from './useCollectionDetails';
 export * from './useCollectionDetailsPolling';
 export * from './useListTokenMetadata';
+export * from './useList1155ShopCardData';
+export * from './useList721ShopCardData';
+export * from './useListMarketCardData';
 export * from './useGetTokenSuppliesMap';
+export * from './useListPrimarySaleItems';
+export * from './useERC721SaleMintedTokens';
+export * from './useCheckoutOptionsSalesContract';

package/src/react/hooks/useBalanceOfCollectible.tsx

@@ -31,14 +31,18 @@ export function useBalanceOfCollectible(args: UseBalanceOfCollectibleArgs) {
 	const config = useConfig();
 	const { data: marketplaceConfig } = useMarketplaceConfig();
 
-	const isLaos721 =
-		marketplaceConfig?.market.collections.find(
-			(collection) => collection.itemsAddress === args.collectionAddress,
-		)?.contractType === ContractType.LAOSERC721;
+	const collection = marketplaceConfig?.market.collections.find(
+		(collection) => collection.itemsAddress === args.collectionAddress,
+	);
+	const isLaos721 = collection?.contractType === ContractType.LAOS_ERC_721;
 
-	if (isLaos721) {
-		args.isLaos721 = true;
-	}
-
-	return useQuery(balanceOfCollectibleOptions(args, config));
+	return useQuery(
+		balanceOfCollectibleOptions(
+			{
+				...args,
+				isLaos721,
+			},
+			config,
+		),
+	);
 }

package/src/react/hooks/useCancelTransactionSteps.tsx

@@ -4,6 +4,7 @@ import {
 	WalletInstanceNotFoundError,
 } from '../../utils/_internal/error/transaction';
 import {
+	ExecuteType,
 	type MarketplaceKind,
 	type Step,
 	StepType,
@@ -46,7 +47,7 @@ export const useCancelTransactionSteps = ({
 	const { wallet, isLoading, isError } = useWallet();
 	const walletIsInitialized = wallet && !isLoading && !isError;
 	const sdkConfig = useConfig();
-	const marketplaceClient = getMarketplaceClient(chainId, sdkConfig);
+	const marketplaceClient = getMarketplaceClient(sdkConfig);
 	const { generateCancelTransactionAsync } = useGenerateCancelTransaction({
 		chainId,
 	});
@@ -95,6 +96,7 @@ export const useCancelTransactionSteps = ({
 			}
 
 			const steps = await generateCancelTransactionAsync({
+				chainId,
 				collectionAddress,
 				maker: address,
 				marketplace,
@@ -230,10 +232,12 @@ export const useCancelTransactionSteps = ({
 		);
 
 		const result = await marketplaceClient.execute({
+			chainId: String(chainId),
 			signature: signature as string,
 			method: signatureStep.post?.method as string,
 			endpoint: signatureStep.post?.endpoint as string,
 			body: signatureStep.post?.body,
+			executeType: ExecuteType.order,
 		});
 
 		return result.orderId;

package/src/react/hooks/useCheckoutOptions.tsx

@@ -33,8 +33,9 @@ const fetchCheckoutOptions = async (
 	args: UseCheckoutOptionsArgs & { walletAddress: Hex },
 	config: SdkConfig,
 ) => {
-	const marketplaceClient = getMarketplaceClient(args.chainId, config);
+	const marketplaceClient = getMarketplaceClient(config);
 	return marketplaceClient.checkoutOptionsMarketplace({
+		chainId: String(args.chainId),
 		wallet: args.walletAddress,
 		orders: args.orders.map((order) => ({
 			contractAddress: order.collectionAddress,

package/src/react/hooks/useCheckoutOptionsSalesContract.tsx

@@ -0,0 +1,67 @@
+import { queryOptions, skipToken, useQuery } from '@tanstack/react-query';
+import type { Hex } from 'viem';
+import { useAccount } from 'wagmi';
+import type { SdkConfig } from '../../types';
+import {
+	type CheckoutOptionsSalesContractArgs,
+	getMarketplaceClient,
+} from '../_internal';
+import { useConfig } from './useConfig';
+
+type UseCheckoutOptionsSalesContractArgs = Omit<
+	CheckoutOptionsSalesContractArgs,
+	'wallet' | 'chainId'
+> & { chainId: number };
+
+const fetchCheckoutOptionsSalesContract = async (
+	args: CheckoutOptionsSalesContractArgs,
+	config: SdkConfig,
+) => {
+	const marketplaceClient = getMarketplaceClient(config);
+	return marketplaceClient.checkoutOptionsSalesContract({
+		chainId: args.chainId,
+		wallet: args.wallet,
+		contractAddress: args.contractAddress,
+		collectionAddress: args.collectionAddress,
+		items: args.items,
+	});
+};
+
+export const checkoutOptionsSalesContractOptions = (
+	args:
+		| (UseCheckoutOptionsSalesContractArgs & { wallet?: Hex })
+		| typeof skipToken,
+	config: SdkConfig,
+) => {
+	return queryOptions({
+		queryKey: ['checkoutOptionsSalesContract', args],
+		queryFn:
+			skipToken === args
+				? skipToken
+				: () =>
+						fetchCheckoutOptionsSalesContract(
+							{
+								chainId: String(args.chainId),
+								// biome-ignore lint/style/noNonNullAssertion: <explanation>
+								wallet: args.wallet!,
+								contractAddress: args.contractAddress,
+								collectionAddress: args.collectionAddress,
+								items: args.items,
+							},
+							config,
+						),
+	});
+};
+
+export const useCheckoutOptionsSalesContract = (
+	args: UseCheckoutOptionsSalesContractArgs | typeof skipToken,
+) => {
+	const { address } = useAccount();
+	const config = useConfig();
+	return useQuery(
+		checkoutOptionsSalesContractOptions(
+			skipToken === args ? skipToken : { ...args, wallet: address },
+			config,
+		),
+	);
+};

package/src/react/hooks/useCollectionDetails.tsx

@@ -6,14 +6,24 @@ import { useConfig } from './useConfig';
 type UseCollectionDetails = {
 	collectionAddress: string;
 	chainId: number;
+	query?: {
+		enabled?: boolean;
+	};
 };
 
-const fetchCollectionDetails = async (
-	args: { collectionAddress: string },
-	marketplaceClient: Awaited<ReturnType<typeof getMarketplaceClient>>,
-) => {
+const fetchCollectionDetails = async ({
+	collectionAddress,
+	chainId,
+	config,
+}: {
+	collectionAddress: string;
+	chainId: number;
+	config: SdkConfig;
+}) => {
+	const marketplaceClient = getMarketplaceClient(config);
 	const { collection } = await marketplaceClient.getCollectionDetail({
-		contractAddress: args.collectionAddress,
+		chainId: String(chainId),
+		contractAddress: collectionAddress,
 	});
 	return collection;
 };
@@ -22,10 +32,15 @@ export const collectionDetailsOptions = (
 	args: UseCollectionDetails,
 	config: SdkConfig,
 ) => {
-	const marketplaceClient = getMarketplaceClient(args.chainId, config);
 	return queryOptions({
 		queryKey: ['collectionDetails', args],
-		queryFn: () => fetchCollectionDetails(args, marketplaceClient),
+		queryFn: () =>
+			fetchCollectionDetails({
+				collectionAddress: args.collectionAddress,
+				chainId: args.chainId,
+				config,
+			}),
+		enabled: args.query?.enabled,
 	});
 };
 

package/src/react/hooks/useCountListingsForCollectible.tsx

@@ -36,11 +36,12 @@ const fetchCountListingsForCollectible = async (
 	config: SdkConfig,
 ) => {
 	const parsedArgs = UseCountListingsForCollectibleArgsSchema.parse(args);
-	const marketplaceClient = getMarketplaceClient(parsedArgs.chainId, config);
+	const marketplaceClient = getMarketplaceClient(config);
+	const { chainId, collectionAddress, collectibleId } = parsedArgs;
 	return marketplaceClient.getCountOfListingsForCollectible({
-		...parsedArgs,
-		contractAddress: parsedArgs.collectionAddress,
-		tokenId: parsedArgs.collectibleId,
+		chainId: String(chainId),
+		contractAddress: collectionAddress,
+		tokenId: collectibleId,
 	});
 };
 

package/src/react/hooks/useCountOfCollectables.tsx

@@ -40,21 +40,24 @@ const fetchCountOfCollectables = async (
 	config: SdkConfig,
 ) => {
 	const parsedArgs = UseCountOfCollectableSchema.parse(args);
-	const marketplaceClient = getMarketplaceClient(parsedArgs.chainId, config);
-	if (parsedArgs.filter) {
+	const marketplaceClient = getMarketplaceClient(config);
+	const { chainId, collectionAddress, filter, side } = parsedArgs;
+
+	if (filter) {
 		return marketplaceClient
 			.getCountOfFilteredCollectibles({
-				...parsedArgs,
-				contractAddress: parsedArgs.collectionAddress,
+				chainId: String(chainId),
+				contractAddress: collectionAddress,
+				filter,
 				// biome-ignore lint/style/noNonNullAssertion: safe to assert here, as it's validated
-				side: parsedArgs.side!,
+				side: side!,
 			})
 			.then((resp) => resp.count);
 	}
 	return marketplaceClient
 		.getCountOfAllCollectibles({
-			...parsedArgs,
-			contractAddress: parsedArgs.collectionAddress,
+			chainId: String(chainId),
+			contractAddress: collectionAddress,
 		})
 		.then((resp) => resp.count);
 };

package/src/react/hooks/useCountOffersForCollectible.tsx

@@ -36,11 +36,12 @@ const fetchCountOffersForCollectible = async (
 	config: SdkConfig,
 ) => {
 	const parsedArgs = UseCountOffersForCollectibleArgsSchema.parse(args);
-	const marketplaceClient = getMarketplaceClient(parsedArgs.chainId, config);
+	const marketplaceClient = getMarketplaceClient(config);
+	const { chainId, collectionAddress, collectibleId } = parsedArgs;
 	return marketplaceClient.getCountOfOffersForCollectible({
-		...parsedArgs,
-		contractAddress: parsedArgs.collectionAddress,
-		tokenId: parsedArgs.collectibleId,
+		chainId: String(chainId),
+		contractAddress: collectionAddress,
+		tokenId: collectibleId,
 	});
 };
 

package/src/react/hooks/useCurrency.tsx

@@ -33,9 +33,9 @@ const fetchCurrency = async (
 		| undefined;
 
 	if (!currencies) {
-		const marketplaceClient = getMarketplaceClient(chainId, config);
+		const marketplaceClient = getMarketplaceClient(config);
 		currencies = await marketplaceClient
-			.listCurrencies()
+			.listCurrencies({ chainId: String(chainId) })
 			.then((resp) => resp.currencies);
 	}