@0xsequence/marketplace-sdk 0.8.9 → 0.8.11

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

@@ -2,95 +2,97 @@
 
 exports[`useMarketplaceConfig > should fetch marketplace config and styles successfully 1`] = `
 {
-  "bannerUrl": "",
-  "collections": [
-    {
-      "address": "0x0000000000000000000000000000000000000000",
-      "bannerUrl": "",
-      "chainId": 1,
-      "currencyOptions": [
-        "0x0000000000000000000000000000000000000000",
-        "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
-      ],
-      "destinationMarketplace": "sequence_marketplace_v2",
-      "exchanges": [],
-      "feePercentage": 3.5,
-      "filterSettings": {
-        "exclusions": [
-          {
-            "condition": "SPECIFIC_VALUE",
-            "key": "Type",
-            "value": "Sample",
-          },
-        ],
-        "filterOrder": [
-          "Type",
-          "Rarity",
+  "market": {
+    "bannerUrl": "https://example.com/market-banner.png",
+    "collections": [
+      {
+        "bannerUrl": "https://example.com/market-banner.png",
+        "chainId": 1,
+        "contractType": "ERC721",
+        "currencyOptions": [
+          "0x0000000000000000000000000000000000000000",
+          "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
         ],
+        "destinationMarketplace": "sequence_marketplace_v2",
+        "feePercentage": 3.5,
+        "filterSettings": {
+          "exclusions": [
+            {
+              "condition": "SPECIFIC_VALUE",
+              "key": "Type",
+              "value": "Sample",
+            },
+          ],
+          "filterOrder": [
+            "Type",
+            "Rarity",
+          ],
+        },
+        "itemsAddress": "0x0000000000000000000000000000000000000000",
+        "marketplaceType": "MARKET",
       },
-      "marketplaceType": "ORDERBOOK",
-    },
-    {
-      "address": "0x1234567890123456789012345678901234567890",
-      "bannerUrl": "https://example.com/collection-banner.png",
-      "chainId": 137,
-      "currencyOptions": [
-        "0x0000000000000000000000000000000000000000",
-      ],
-      "destinationMarketplace": "opensea",
-      "exchanges": [],
-      "feePercentage": 2.5,
-      "filterSettings": {
-        "exclusions": [
-          {
-            "condition": "ENTIRE_KEY",
-            "key": "Category",
-          },
-          {
-            "condition": "SPECIFIC_VALUE",
-            "key": "Level",
-            "value": "Legendary",
-          },
-        ],
-        "filterOrder": [
-          "Category",
-          "Level",
-          "Element",
+      {
+        "bannerUrl": "https://example.com/collection-banner.png",
+        "chainId": 137,
+        "contractType": "ERC1155",
+        "currencyOptions": [
+          "0x0000000000000000000000000000000000000000",
         ],
+        "destinationMarketplace": "opensea",
+        "feePercentage": 2.5,
+        "filterSettings": {
+          "exclusions": [
+            {
+              "condition": "ENTIRE_KEY",
+              "key": "Category",
+            },
+            {
+              "condition": "SPECIFIC_VALUE",
+              "key": "Level",
+              "value": "Legendary",
+            },
+          ],
+          "filterOrder": [
+            "Category",
+            "Level",
+            "Element",
+          ],
+        },
+        "itemsAddress": "0x1234567890123456789012345678901234567890",
+        "marketplaceType": "MARKET",
       },
-      "marketplaceType": "ORDERBOOK",
+    ],
+    "enabled": true,
+    "ogImage": "https://example.com/og-image.png",
+  },
+  "projectId": NaN,
+  "settings": {
+    "accessKey": "mock-access-key",
+    "faviconUrl": "https://example.com/favicon.ico",
+    "fontUrl": "https://example.com/font.woff2",
+    "logoUrl": "https://example.com/logo.png",
+    "publisherId": "publisher-1",
+    "socials": {
+      "discord": "https://discord.gg/mock",
+      "instagram": "https://instagram.com/mock",
+      "tiktok": "https://tiktok.com/@mock",
+      "twitter": "https://twitter.com/mock",
+      "website": "https://mock.com",
+      "youtube": "https://youtube.com/mock",
+    },
+    "title": "Mock Marketplace",
+    "walletOptions": {
+      "connectors": [],
+      "includeEIP6963Wallets": true,
+      "oidcIssuers": {},
+      "walletType": "UNIVERSAL",
     },
-  ],
-  "cssString": "
-  .marketplace-theme {
-    --primary-color: #000000;
-  }
-",
-  "faviconUrl": "https://example.com/favicon.png",
-  "landingBannerUrl": "https://example.com/banner.png",
-  "landingPageLayout": "default",
-  "logoUrl": "https://example.com/logo.png",
-  "manifestUrl": "https://api.sequence.build/marketplace//manifest.json",
-  "projectId": 1,
-  "publisherId": "test-publisher",
-  "shortDescription": "A test marketplace",
-  "socials": {
-    "discord": "https://discord.com/test",
-    "instagram": "https://instagram.com/test",
-    "tiktok": "",
-    "twitter": "https://twitter.com/test",
-    "website": "",
-    "youtube": "",
   },
-  "title": "Test Marketplace",
-  "walletOptions": {
-    "connectors": [
-      "coinbase",
-      "walletconnect",
-    ],
-    "includeEIP6963Wallets": true,
-    "oidcIssuers": {},
-    "walletType": "UNIVERSAL",
+  "shop": {
+    "bannerUrl": "",
+    "collections": [],
+    "enabled": false,
+    "ogImage": undefined,
   },
 }
 `;

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

@@ -85,22 +85,6 @@ describe('useFilters', () => {
 		`);
 	});
 
-	it('should validate input parameters', async () => {
-		const invalidArgs: UseFiltersArgs = {
-			...defaultArgs,
-			// @ts-expect-error
-			chainId: {}, // Using an object instead of a string/number will fail validation
-		};
-
-		const { result } = renderHook(() => useFilters(invalidArgs));
-
-		await waitFor(() => {
-			expect(result.current.isError).toBe(true);
-		});
-
-		expect(result.current.error).toBeDefined();
-	});
-
 	it('should return filter values in correct format', async () => {
 		const { result } = renderHook(() => useFilters(defaultArgs));
 

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

@@ -1,9 +1,10 @@
 import { renderHook, server, waitFor } from '@test';
 import { http, HttpResponse } from 'msw';
-import { zeroAddress } from 'viem';
+import { type Address, zeroAddress } from 'viem';
 import { beforeEach, describe, expect, it } from 'vitest';
+import { ContractType } from '../../_internal';
 import {
-	createLookupMarketplaceConfigHandler,
+	createLookupMarketplaceHandler,
 	mockConfig,
 } from '../../_internal/api/__mocks__/builder.msw';
 import {
@@ -14,6 +15,7 @@ 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';
 
@@ -22,8 +24,7 @@ mockCollectibleOrder.metadata.tokenId = '1';
 
 describe('useInventory', () => {
 	const defaultArgs: UseInventoryArgs = {
-		accountAddress:
-			'0x1234567890123456789012345678901234567890' as `0x${string}`,
+		accountAddress: '0x1234567890123456789012345678901234567890' as Address,
 		chainId: 1,
 		collectionAddress: zeroAddress,
 	};
@@ -67,7 +68,7 @@ describe('useInventory', () => {
 				...defaultArgs,
 				// Add a unique key to avoid caching
 				collectionAddress:
-					'0xdeadbeef0000000000000000000000000000dead' as `0x${string}`,
+					'0xdeadbeef0000000000000000000000000000dead' as Address,
 			}),
 		);
 
@@ -97,7 +98,7 @@ describe('useInventory', () => {
 		const newArgs = {
 			...defaultArgs,
 			collectionAddress:
-				'0x1234567890123456789012345678901234567890' as `0x${string}`,
+				'0x1234567890123456789012345678901234567890' as Address,
 		};
 
 		rerender(() => useInventory(newArgs));
@@ -133,19 +134,19 @@ describe('useInventory', () => {
 		const laosCollectionAddress = '0x1234567890123456789012345678901234567890';
 		const configWithLaos = {
 			...mockConfig,
-			collections: [
+			marketCollections: [
 				{
-					...mockConfig.collections[0],
-					address: laosCollectionAddress,
-					isLAOSERC721: true,
+					...mockConfig.marketCollections[0],
+					itemsAddress: laosCollectionAddress,
+					contractType: ContractType.LAOSERC721,
 				},
 			],
-		};
-		server.use(createLookupMarketplaceConfigHandler(configWithLaos));
+		} satisfies LookupMarketplaceReturn;
+		server.use(createLookupMarketplaceHandler(configWithLaos));
 
 		const laosArgs: UseInventoryArgs = {
 			...defaultArgs,
-			collectionAddress: laosCollectionAddress as `0x${string}`,
+			collectionAddress: laosCollectionAddress as Address,
 		};
 
 		const { result } = renderHook(() => useInventory(laosArgs));
@@ -245,10 +246,9 @@ describe('useInventory', () => {
 		// Use unique test args to avoid caching issues
 		const testArgs = {
 			...defaultArgs,
-			accountAddress:
-				'0xabcdef1234567890abcdef1234567890abcdef12' as `0x${string}`,
+			accountAddress: '0xabcdef1234567890abcdef1234567890abcdef12' as Address,
 			collectionAddress:
-				'0xabcdef1234567890abcdef1234567890abcdef12' as `0x${string}`,
+				'0xabcdef1234567890abcdef1234567890abcdef12' as Address,
 		};
 
 		const { result } = renderHook(() => useInventory(testArgs));

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

@@ -1,15 +1,13 @@
 import { renderHook, server, waitFor } from '@test';
 import { http, HttpResponse } from 'msw';
+import type { Address } from 'viem';
 import { describe, expect, it } from 'vitest';
-import { MarketplaceType, OrderbookKind } from '../../../types';
+import { OrderbookKind } from '../../_internal';
 import {
-	createLookupMarketplaceConfigHandler,
+	createLookupMarketplaceHandler,
 	mockConfig,
 } from '../../_internal/api/__mocks__/builder.msw';
-import {
-	mockEthCollection,
-	mockPolCollection,
-} from '../../_internal/api/__mocks__/metadata.msw';
+import { mockEthCollection } from '../../_internal/api/__mocks__/metadata.msw';
 import { useListCollections } from '../useListCollections';
 
 describe('useListCollections', () => {
@@ -22,16 +20,16 @@ describe('useListCollections', () => {
 		});
 
 		// Verify the data matches our mock
-		expect(result.current.data).toEqual([mockEthCollection, mockPolCollection]);
+		expect(result.current.data).toMatchSnapshot();
 		expect(result.current.error).toBeNull();
 	});
 
 	it('should handle empty collections', async () => {
 		// Mock marketplace config with empty collections
 		server.use(
-			createLookupMarketplaceConfigHandler({
+			createLookupMarketplaceHandler({
 				...mockConfig,
-				collections: [],
+				marketCollections: [],
 			}),
 		);
 
@@ -45,61 +43,31 @@ describe('useListCollections', () => {
 		expect(result.current.error).toBeNull();
 	});
 
-	it('should handle error states', async () => {
-		// Mock marketplace config with collection
-		server.use(
-			createLookupMarketplaceConfigHandler({
-				...mockConfig,
-				collections: [
-					{
-						chainId: 1,
-						address:
-							'0x1234567890123456789012345678901234567890' as `0x${string}`,
-						feePercentage: 2.5,
-						marketplaceType: MarketplaceType.ORDERBOOK,
-						currencyOptions: [],
-						exchanges: [],
-						bannerUrl: '',
-						destinationMarketplace: OrderbookKind.sequence_marketplace_v2,
-					},
-				],
-			}),
-			http.post('*/rpc/Metadata/GetContractInfoBatch', () => {
-				return new HttpResponse(
-					JSON.stringify({ error: { message: 'Failed to fetch collections' } }),
-					{ status: 500 },
-				);
-			}),
-		);
-
-		const { result } = renderHook(() => useListCollections());
-
-		await waitFor(() => {
-			expect(result.current.isError).toBe(true);
-		});
-
-		expect(result.current.error).toBeDefined();
-		expect(result.current.data).toBeUndefined();
-	});
-
 	it('should handle disabled queries', async () => {
 		let requestMade = false;
 
 		// Mock marketplace config with collection
 		server.use(
-			createLookupMarketplaceConfigHandler({
+			createLookupMarketplaceHandler({
 				...mockConfig,
-				collections: [
+				marketCollections: [
 					{
+						id: 1,
+						projectId: 1,
+						contractType: 'ERC721',
 						chainId: 1,
-						address:
-							'0x1234567890123456789012345678901234567890' as `0x${string}`,
+						itemsAddress:
+							'0x1234567890123456789012345678901234567890' as Address,
 						feePercentage: 2.5,
-						marketplaceType: MarketplaceType.ORDERBOOK,
 						currencyOptions: [],
-						exchanges: [],
 						bannerUrl: '',
-						destinationMarketplace: OrderbookKind.sequence_marketplace_v2,
+						destinationMarketplace: OrderbookKind.opensea,
+						filterSettings: {
+							filterOrder: ['Category', 'Level', 'Element'],
+							exclusions: [],
+						},
+						createdAt: new Date('2025-03-16T13:04:16.098Z').toISOString(),
+						updatedAt: new Date('2025-03-16T13:04:16.098Z').toISOString(),
 					},
 				],
 			}),
@@ -129,14 +97,13 @@ describe('useListCollections', () => {
 	});
 
 	it('should handle multiple collections from different chains', async () => {
-		// TODO: This test should be more robust, make sure we validate that the marketplace config has multiple chains
-		// then the to equal should just check that we are fetching the data from those
 		const { result } = renderHook(() => useListCollections());
 
 		await waitFor(() => {
 			expect(result.current.data).toBeDefined();
 		});
 
-		expect(result.current.data).toEqual([mockEthCollection, mockPolCollection]);
+		const set = new Set(result.current.data?.map((c) => c.chainId));
+		expect(set.size).toBeGreaterThan(1);
 	});
 });

package/src/react/hooks/__tests__/{useCurrencies.test.tsx → useMarketCurrencies.test.tsx}

@@ -1,21 +1,22 @@
 import { renderHook, server, waitFor } from '@test';
 import { USDC_ADDRESS } from '@test/const';
 import { http, HttpResponse } from 'msw';
+import type { Address } from 'viem';
 import { describe, expect, it } from 'vitest';
 import { mockConfig } from '../../_internal/api/__mocks__/builder.msw';
 import {
 	mockCurrencies,
 	mockMarketplaceEndpoint,
 } from '../../_internal/api/__mocks__/marketplace.msw';
-import { useCurrencies } from '../useCurrencies';
+import { useMarketCurrencies } from '../useMarketCurrencies';
 
-describe('useCurrencies', () => {
+describe('useMarketCurrencies', () => {
 	const defaultArgs = {
 		chainId: 1,
 	};
 
 	it('should fetch currencies successfully', async () => {
-		const { result } = renderHook(() => useCurrencies(defaultArgs));
+		const { result } = renderHook(() => useMarketCurrencies(defaultArgs));
 
 		// Initially loading
 		expect(result.current.isLoading).toBe(true);
@@ -37,7 +38,7 @@ describe('useCurrencies', () => {
 			includeNativeCurrency: false,
 		};
 
-		const { result } = renderHook(() => useCurrencies(argsWithoutNative));
+		const { result } = renderHook(() => useMarketCurrencies(argsWithoutNative));
 
 		await waitFor(() => {
 			expect(result.current.isLoading).toBe(false);
@@ -51,10 +52,11 @@ describe('useCurrencies', () => {
 	it('should filter currencies by collection address', async () => {
 		const args = {
 			...defaultArgs,
-			collectionAddress: mockConfig.collections[1].address,
-		} satisfies Parameters<typeof useCurrencies>[0];
+			collectionAddress: mockConfig.marketCollections[1]
+				.itemsAddress as Address,
+		} satisfies Parameters<typeof useMarketCurrencies>[0];
 
-		const { result } = renderHook(() => useCurrencies(args));
+		const { result } = renderHook(() => useMarketCurrencies(args));
 
 		await waitFor(() => {
 			expect(result.current.isLoading).toBe(false);
@@ -64,7 +66,7 @@ describe('useCurrencies', () => {
 			(c) => c.contractAddress,
 		);
 		expect(currencyAddresses).toEqual(
-			mockConfig.collections[1].currencyOptions,
+			mockConfig.marketCollections[1].currencyOptions,
 		);
 	});
 
@@ -79,7 +81,7 @@ describe('useCurrencies', () => {
 			}),
 		);
 
-		const { result } = renderHook(() => useCurrencies(defaultArgs));
+		const { result } = renderHook(() => useMarketCurrencies(defaultArgs));
 
 		await waitFor(() => {
 			expect(result.current.isError).toBe(true);
@@ -90,7 +92,9 @@ describe('useCurrencies', () => {
 	});
 
 	it('should refetch when chainId changes', async () => {
-		const { result, rerender } = renderHook(() => useCurrencies(defaultArgs));
+		const { result, rerender } = renderHook(() =>
+			useMarketCurrencies(defaultArgs),
+		);
 
 		// Wait for initial data
 		await waitFor(() => {
@@ -103,7 +107,7 @@ describe('useCurrencies', () => {
 			chainId: 5,
 		};
 
-		rerender(() => useCurrencies(newArgs));
+		rerender(() => useMarketCurrencies(newArgs));
 
 		// Wait for new data
 		await waitFor(() => {
@@ -123,7 +127,7 @@ describe('useCurrencies', () => {
 			},
 		};
 
-		const { result } = renderHook(() => useCurrencies(argsWithQuery));
+		const { result } = renderHook(() => useMarketCurrencies(argsWithQuery));
 
 		// Should not fetch when disabled
 		expect(result.current.isLoading).toBe(false);
@@ -137,7 +141,9 @@ describe('useCurrencies', () => {
 			currencyOptions: [USDC_ADDRESS],
 		};
 
-		const { result } = renderHook(() => useCurrencies(argsWithCombinedFilters));
+		const { result } = renderHook(() =>
+			useMarketCurrencies(argsWithCombinedFilters),
+		);
 
 		await waitFor(() => {
 			expect(result.current.isLoading).toBe(false);
@@ -168,9 +174,9 @@ describe('useCurrencies', () => {
 			...defaultArgs,
 			includeNativeCurrency: false,
 			collectionAddress: '0x1234567890123456789012345678901234567890',
-		} satisfies Parameters<typeof useCurrencies>[0];
+		} satisfies Parameters<typeof useMarketCurrencies>[0];
 
-		const { result } = renderHook(() => useCurrencies(args));
+		const { result } = renderHook(() => useMarketCurrencies(args));
 
 		await waitFor(() => {
 			expect(result.current.isLoading).toBe(false);

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

@@ -1,12 +1,7 @@
 import { renderHook, server, waitFor } from '@test';
 import { describe, expect, it } from 'vitest';
-import { createLookupMarketplaceConfigErrorHandler } from '../../_internal/api/__mocks__/builder.msw';
+import { createLookupMarketplaceErrorHandler } from '../../_internal/api/__mocks__/builder.msw';
 
-import {
-	createStylesErrorHandler,
-	mockConfig,
-	mockStyles,
-} from '../../_internal/api/__mocks__/builder.msw';
 import { useMarketplaceConfig } from '../useMarketplaceConfig';
 
 describe('useMarketplaceConfig', () => {
@@ -30,7 +25,7 @@ describe('useMarketplaceConfig', () => {
 
 	it('should handle config fetch error', async () => {
 		// Override the handler for this test to return an error
-		server.use(createLookupMarketplaceConfigErrorHandler());
+		server.use(createLookupMarketplaceErrorHandler());
 
 		const { result } = renderHook(() => useMarketplaceConfig());
 
@@ -41,56 +36,4 @@ describe('useMarketplaceConfig', () => {
 		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());
-
-		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(
-			createLookupMarketplaceConfigErrorHandler(),
-			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/index.ts

@@ -7,7 +7,7 @@ export * from './useCollectionBalanceDetails';
 export * from './useComparePrices';
 export * from './useConfig';
 export * from './useConvertPriceToUSD';
-export * from './useCurrencies';
+export * from './useMarketCurrencies';
 export * from './useCurrency';
 export * from './useFilters';
 export * from './useFilterState';
@@ -36,3 +36,5 @@ export * from './useListCollections';
 export * from './useCancelOrder';
 export * from './useCollectionDetails';
 export * from './useCollectionDetailsPolling';
+export * from './useListTokenMetadata';
+export * from './useGetTokenSuppliesMap';

package/src/react/hooks/useBalanceOfCollectible.tsx

@@ -1,4 +1,5 @@
 import { useQuery } from '@tanstack/react-query';
+import { ContractType } from '../_internal';
 import {
 	type UseBalanceOfCollectibleArgs,
 	balanceOfCollectibleOptions,
@@ -30,9 +31,10 @@ export function useBalanceOfCollectible(args: UseBalanceOfCollectibleArgs) {
 	const config = useConfig();
 	const { data: marketplaceConfig } = useMarketplaceConfig();
 
-	const isLaos721 = marketplaceConfig?.collections.find(
-		(collection) => collection.address === args.collectionAddress,
-	)?.isLAOSERC721;
+	const isLaos721 =
+		marketplaceConfig?.market.collections.find(
+			(collection) => collection.itemsAddress === args.collectionAddress,
+		)?.contractType === ContractType.LAOSERC721;
 
 	if (isLaos721) {
 		args.isLaos721 = true;

package/src/react/hooks/useConvertPriceToUSD.tsx

@@ -8,8 +8,8 @@ import {
 	currencyKeys,
 	getQueryClient,
 } from '../_internal';
+import { currenciesOptions } from '../queries/marketCurrencies';
 import { useConfig } from './useConfig';
-import { currenciesOptions } from './useCurrencies';
 
 const UseConvertPriceToUSDArgsSchema = z.object({
 	chainId: z.number(),