@0xsequence/marketplace-sdk 0.8.11 → 0.9.0

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

@@ -8,6 +8,7 @@ exports[`useListCollections > should fetch collections successfully 1`] = `
     "bytecodeHash": "0x1234567890",
     "chainId": 1,
     "contractType": "ERC721",
+    "createdAt": "2025-03-16T13:04:16.098Z",
     "currencyOptions": [
       "0x0000000000000000000000000000000000000000",
       "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
@@ -44,10 +45,12 @@ exports[`useListCollections > should fetch collections successfully 1`] = `
         "Rarity",
       ],
     },
+    "id": 1,
     "itemsAddress": "0x0000000000000000000000000000000000000000",
     "logoURI": "https://example.com/logo.png",
-    "marketplaceType": "MARKET",
+    "marketplaceType": "market",
     "name": "Mock Collection",
+    "projectId": 1,
     "source": "https://example.com/source",
     "status": "AVAILABLE",
     "symbol": "MOCK",
@@ -60,6 +63,7 @@ exports[`useListCollections > should fetch collections successfully 1`] = `
     "bytecodeHash": "0x1234567890",
     "chainId": 137,
     "contractType": "ERC1155",
+    "createdAt": "2025-03-16T13:04:16.098Z",
     "currencyOptions": [
       "0x0000000000000000000000000000000000000000",
     ],
@@ -100,15 +104,190 @@ exports[`useListCollections > should fetch collections successfully 1`] = `
         "Element",
       ],
     },
+    "id": 2,
     "itemsAddress": "0x1234567890123456789012345678901234567890",
     "logoURI": "https://example.com/logo.png",
-    "marketplaceType": "MARKET",
+    "marketplaceType": "market",
     "name": "Mock Collection",
+    "projectId": 1,
     "source": "https://example.com/source",
     "status": "AVAILABLE",
     "symbol": "MOCK",
     "type": "ERC721",
     "updatedAt": "2025-05-01T04:39:56.936Z",
   },
+  {
+    "address": "0x0000000000000000000000000000000000000000",
+    "bannerUrl": "https://example.com/shop-banner.png",
+    "bytecodeHash": "0x1234567890",
+    "chainId": 1,
+    "createdAt": "2025-03-16T13:04:16.098Z",
+    "deployed": true,
+    "extensions": {
+      "blacklist": false,
+      "categories": [
+        "Mock",
+      ],
+      "description": "A mock collection for testing",
+      "featureIndex": 0,
+      "featured": true,
+      "link": "https://example.com",
+      "ogImage": "https://example.com/image.png",
+      "ogName": "Mock Collection",
+      "originAddress": "0x0000000000000000000000000000000000000000",
+      "originChainId": 1,
+      "verified": true,
+      "verifiedBy": "0x",
+    },
+    "id": 1,
+    "itemsAddress": "0x0000000000000000000000000000000000000000",
+    "logoURI": "https://example.com/logo.png",
+    "marketplaceType": "shop",
+    "name": "Mock Collection",
+    "projectId": 1,
+    "saleAddress": "0x0000000000000000000000000000000000000000",
+    "saleBannerUrl": "https://example.com/shop-sale-banner.png",
+    "source": "https://example.com/source",
+    "status": "AVAILABLE",
+    "symbol": "MOCK",
+    "tokenIds": [
+      "1",
+      "2",
+      "3",
+    ],
+    "type": "ERC721",
+    "updatedAt": "2025-05-01T04:39:56.936Z",
+  },
+  {
+    "address": "0x1234567890123456789012345678901234567890",
+    "bannerUrl": "https://example.com/polygon-shop-banner.png",
+    "bytecodeHash": "0x1234567890",
+    "chainId": 137,
+    "createdAt": "2025-03-16T13:04:16.098Z",
+    "deployed": true,
+    "extensions": {
+      "blacklist": false,
+      "categories": [
+        "Mock",
+      ],
+      "description": "A mock collection for testing",
+      "featureIndex": 0,
+      "featured": true,
+      "link": "https://example.com",
+      "ogImage": "https://example.com/image.png",
+      "ogName": "Mock Collection",
+      "originAddress": "0x0000000000000000000000000000000000000000",
+      "originChainId": 1,
+      "verified": true,
+      "verifiedBy": "0x",
+    },
+    "id": 2,
+    "itemsAddress": "0x1234567890123456789012345678901234567890",
+    "logoURI": "https://example.com/logo.png",
+    "marketplaceType": "shop",
+    "name": "Mock Collection",
+    "projectId": 1,
+    "saleAddress": "0x1234567890123456789012345678901234567890",
+    "saleBannerUrl": "https://example.com/polygon-shop-sale-banner.png",
+    "source": "https://example.com/source",
+    "status": "AVAILABLE",
+    "symbol": "MOCK",
+    "tokenIds": [
+      "4",
+      "5",
+      "6",
+    ],
+    "type": "ERC721",
+    "updatedAt": "2025-05-01T04:39:56.936Z",
+  },
+]
+`;
+
+exports[`useListCollections > should handle empty collections 1`] = `
+[
+  {
+    "address": "0x0000000000000000000000000000000000000000",
+    "bannerUrl": "https://example.com/shop-banner.png",
+    "bytecodeHash": "0x1234567890",
+    "chainId": 1,
+    "createdAt": "2025-03-16T13:04:16.098Z",
+    "deployed": true,
+    "extensions": {
+      "blacklist": false,
+      "categories": [
+        "Mock",
+      ],
+      "description": "A mock collection for testing",
+      "featureIndex": 0,
+      "featured": true,
+      "link": "https://example.com",
+      "ogImage": "https://example.com/image.png",
+      "ogName": "Mock Collection",
+      "originAddress": "0x0000000000000000000000000000000000000000",
+      "originChainId": 1,
+      "verified": true,
+      "verifiedBy": "0x",
+    },
+    "id": 1,
+    "itemsAddress": "0x0000000000000000000000000000000000000000",
+    "logoURI": "https://example.com/logo.png",
+    "marketplaceType": "shop",
+    "name": "Mock Collection",
+    "projectId": 1,
+    "saleAddress": "0x0000000000000000000000000000000000000000",
+    "saleBannerUrl": "https://example.com/shop-sale-banner.png",
+    "source": "https://example.com/source",
+    "status": "AVAILABLE",
+    "symbol": "MOCK",
+    "tokenIds": [
+      "1",
+      "2",
+      "3",
+    ],
+    "type": "ERC721",
+    "updatedAt": "2025-05-01T04:39:56.936Z",
+  },
+  {
+    "address": "0x1234567890123456789012345678901234567890",
+    "bannerUrl": "https://example.com/polygon-shop-banner.png",
+    "bytecodeHash": "0x1234567890",
+    "chainId": 137,
+    "createdAt": "2025-03-16T13:04:16.098Z",
+    "deployed": true,
+    "extensions": {
+      "blacklist": false,
+      "categories": [
+        "Mock",
+      ],
+      "description": "A mock collection for testing",
+      "featureIndex": 0,
+      "featured": true,
+      "link": "https://example.com",
+      "ogImage": "https://example.com/image.png",
+      "ogName": "Mock Collection",
+      "originAddress": "0x0000000000000000000000000000000000000000",
+      "originChainId": 1,
+      "verified": true,
+      "verifiedBy": "0x",
+    },
+    "id": 2,
+    "itemsAddress": "0x1234567890123456789012345678901234567890",
+    "logoURI": "https://example.com/logo.png",
+    "marketplaceType": "shop",
+    "name": "Mock Collection",
+    "projectId": 1,
+    "saleAddress": "0x1234567890123456789012345678901234567890",
+    "saleBannerUrl": "https://example.com/polygon-shop-sale-banner.png",
+    "source": "https://example.com/source",
+    "status": "AVAILABLE",
+    "symbol": "MOCK",
+    "tokenIds": [
+      "4",
+      "5",
+      "6",
+    ],
+    "type": "ERC721",
+    "updatedAt": "2025-05-01T04:39:56.936Z",
+  },
 ]
 `;

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

@@ -9,6 +9,7 @@ exports[`useMarketplaceConfig > should fetch marketplace config and styles succe
         "bannerUrl": "https://example.com/market-banner.png",
         "chainId": 1,
         "contractType": "ERC721",
+        "createdAt": "2025-03-16T13:04:16.098Z",
         "currencyOptions": [
           "0x0000000000000000000000000000000000000000",
           "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
@@ -28,13 +29,17 @@ exports[`useMarketplaceConfig > should fetch marketplace config and styles succe
             "Rarity",
           ],
         },
+        "id": 1,
         "itemsAddress": "0x0000000000000000000000000000000000000000",
-        "marketplaceType": "MARKET",
+        "marketplaceType": "market",
+        "projectId": 1,
+        "updatedAt": "2025-03-16T13:04:16.098Z",
       },
       {
         "bannerUrl": "https://example.com/collection-banner.png",
         "chainId": 137,
         "contractType": "ERC1155",
+        "createdAt": "2025-03-16T13:04:16.098Z",
         "currencyOptions": [
           "0x0000000000000000000000000000000000000000",
         ],
@@ -58,12 +63,16 @@ exports[`useMarketplaceConfig > should fetch marketplace config and styles succe
             "Element",
           ],
         },
+        "id": 2,
         "itemsAddress": "0x1234567890123456789012345678901234567890",
-        "marketplaceType": "MARKET",
+        "marketplaceType": "market",
+        "projectId": 1,
+        "updatedAt": "2025-03-16T13:04:16.098Z",
       },
     ],
     "enabled": true,
     "ogImage": "https://example.com/og-image.png",
+    "private": false,
   },
   "projectId": NaN,
   "settings": {
@@ -80,6 +89,7 @@ exports[`useMarketplaceConfig > should fetch marketplace config and styles succe
       "website": "https://mock.com",
       "youtube": "https://youtube.com/mock",
     },
+    "style": {},
     "title": "Mock Marketplace",
     "walletOptions": {
       "connectors": [],
@@ -89,10 +99,48 @@ exports[`useMarketplaceConfig > should fetch marketplace config and styles succe
     },
   },
   "shop": {
-    "bannerUrl": "",
-    "collections": [],
-    "enabled": false,
-    "ogImage": undefined,
+    "bannerUrl": "https://example.com/shop-banner.png",
+    "collections": [
+      {
+        "bannerUrl": "https://example.com/shop-banner.png",
+        "chainId": 1,
+        "createdAt": "2025-03-16T13:04:16.098Z",
+        "id": 1,
+        "itemsAddress": "0x0000000000000000000000000000000000000000",
+        "marketplaceType": "shop",
+        "name": "Mock Shop Collection",
+        "projectId": 1,
+        "saleAddress": "0x0000000000000000000000000000000000000000",
+        "saleBannerUrl": "https://example.com/shop-sale-banner.png",
+        "tokenIds": [
+          "1",
+          "2",
+          "3",
+        ],
+        "updatedAt": "2025-03-16T13:04:16.098Z",
+      },
+      {
+        "bannerUrl": "https://example.com/polygon-shop-banner.png",
+        "chainId": 137,
+        "createdAt": "2025-03-16T13:04:16.098Z",
+        "id": 2,
+        "itemsAddress": "0x1234567890123456789012345678901234567890",
+        "marketplaceType": "shop",
+        "name": "Polygon Shop Collection",
+        "projectId": 1,
+        "saleAddress": "0x1234567890123456789012345678901234567890",
+        "saleBannerUrl": "https://example.com/polygon-shop-sale-banner.png",
+        "tokenIds": [
+          "4",
+          "5",
+          "6",
+        ],
+        "updatedAt": "2025-03-16T13:04:16.098Z",
+      },
+    ],
+    "enabled": true,
+    "ogImage": "https://example.com/shop-og-image.png",
+    "private": false,
   },
 }
 `;

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

@@ -1,5 +1,5 @@
 import { renderHook, server, waitFor } from '@test';
-import { http, HttpResponse } from 'msw';
+import { HttpResponse, http } from 'msw';
 import { zeroAddress } from 'viem';
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 import { useDisconnect } from 'wagmi';
@@ -86,10 +86,13 @@ describe('useAutoSelectFeeOption', () => {
 		const { result } = renderHook(() => useAutoSelectFeeOption(defaultArgs));
 
 		// Wait for the hook to complete
-		await waitFor(async () => {
-			const response = await result.current;
-			expect(response.selectedOption).toBe(mockFeeOptions[0]);
-		});
+		await waitFor(
+			async () => {
+				const response = await result.current;
+				expect(response.selectedOption).toBe(mockFeeOptions[0]);
+			},
+			{ timeout: 5000 },
+		);
 
 		// Verify final state
 		const finalResponse = await result.current;

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

@@ -1,5 +1,5 @@
 import { renderHook, server, waitFor } from '@test';
-import { http, HttpResponse } from 'msw';
+import { HttpResponse, http } from 'msw';
 import { zeroAddress } from 'viem';
 import { describe, expect, it } from 'vitest';
 import {

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

@@ -1,5 +1,5 @@
 import { renderHook, server, waitFor } from '@test';
-import { http, HttpResponse } from 'msw';
+import { HttpResponse, http } from 'msw';
 import { beforeEach, describe, expect, it, vi } from 'vitest';
 import {
 	commonWalletMocks,
@@ -81,7 +81,7 @@ describe('useCancelOrder', () => {
 				orderId: mockOrderId,
 				marketplace: MarketplaceKind.sequence_marketplace_v2,
 			});
-		} catch (error) {
+		} catch (_error) {
 			// Error is expected
 		}
 
@@ -171,7 +171,7 @@ describe('useCancelOrder', () => {
 				orderId: mockOrderId,
 				marketplace: MarketplaceKind.sequence_marketplace_v2,
 			});
-		} catch (error) {
+		} catch (_error) {
 			// Error is expected
 		}
 
@@ -235,7 +235,7 @@ describe('useCancelOrder', () => {
 				orderId: mockOrderId,
 				marketplace: MarketplaceKind.sequence_marketplace_v2,
 			});
-		} catch (error) {
+		} catch (_error) {
 			// Error is expected
 		}
 

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

@@ -1,5 +1,5 @@
 import { renderHook, server, waitFor } from '@test';
-import { http, HttpResponse } from 'msw';
+import { HttpResponse, http } from 'msw';
 import { zeroAddress } from 'viem';
 import type { Mock } from 'vitest';
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';

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__/useCollectible.test.tsx

@@ -1,16 +1,16 @@
 import { renderHook, server, waitFor } from '@test';
-import { http, HttpResponse } from 'msw';
+import { HttpResponse, http } from 'msw';
 import { zeroAddress } from 'viem';
 import { describe, expect, it } from 'vitest';
 import {
 	mockMetadataEndpoint,
 	mockTokenMetadata,
 } from '../../_internal/api/__mocks__/metadata.msw';
-import type { UseCollectibleArgs } from '../useCollectible';
+import type { UseCollectibleParams } from '../useCollectible';
 import { useCollectible } from '../useCollectible';
 
 describe('useCollectible', () => {
-	const defaultArgs: UseCollectibleArgs = {
+	const defaultArgs: UseCollectibleParams = {
 		chainId: 1,
 		collectionAddress: zeroAddress,
 		collectibleId: '1',
@@ -84,7 +84,7 @@ describe('useCollectible', () => {
 	});
 
 	it('should handle undefined query params', async () => {
-		const argsWithoutQuery: UseCollectibleArgs = {
+		const argsWithoutQuery: UseCollectibleParams = {
 			chainId: 1,
 			collectionAddress: zeroAddress,
 			collectibleId: '1',
@@ -101,19 +101,17 @@ describe('useCollectible', () => {
 		expect(result.current.error).toBeNull();
 	});
 
-	it('should validate input parameters', async () => {
-		const invalidArgs: UseCollectibleArgs = {
-			...defaultArgs,
-			// @ts-expect-error
-			chainId: {}, // Using an object instead of a string/number will fail validation
-		};
+	it('should not fetch when required params are missing', async () => {
+		const incompleteArgs = {
+			chainId: 1,
+			// Missing collectionAddress and collectibleId
+		} as UseCollectibleParams;
 
-		const { result } = renderHook(() => useCollectible(invalidArgs));
+		const { result } = renderHook(() => useCollectible(incompleteArgs));
 
-		await waitFor(() => {
-			expect(result.current.isError).toBe(true);
-		});
-
-		expect(result.current.error).toBeDefined();
+		// Should not be loading since enabled condition fails
+		expect(result.current.isLoading).toBe(false);
+		expect(result.current.isFetching).toBe(false);
+		expect(result.current.data).toBeUndefined();
 	});
 });