@0xsequence/marketplace-sdk 0.9.0 → 1.0.0

package/src/react/hooks/data/collectibles/index.ts

@@ -0,0 +1,6 @@
+export * from './useBalanceOfCollectible';
+export * from './useCollectible';
+export * from './useCountOfCollectables';
+export * from './useListCollectibleActivities';
+export * from './useListCollectibles';
+export * from './useListCollectiblesPaginated';

package/src/react/hooks/data/collectibles/useBalanceOfCollectible.laos.test.tsx

@@ -0,0 +1,367 @@
+import { renderHook, server, waitFor } from '@test';
+import { HttpResponse, http } from 'msw';
+import { afterEach, describe, expect, it } from 'vitest';
+import { ContractType } from '../../../_internal';
+import {
+	mockIndexerEndpoint,
+	mockTokenBalance,
+} from '../../../_internal/api/__mocks__/indexer.msw';
+import {
+	laosHandlers,
+	mockTokenBalancesResponse,
+} from '../../../_internal/api/__mocks__/laos.msw';
+import { useBalanceOfCollectible } from './useBalanceOfCollectible';
+
+describe('useBalanceOfCollectible with LAOS', () => {
+	const defaultArgs = {
+		collectionAddress:
+			'0x1234567890123456789012345678901234567890' as `0x${string}`,
+		collectableId: '1',
+		userAddress:
+			'0xuser1234567890123456789012345678901234567890' as `0x${string}`,
+		chainId: 11155111,
+	};
+
+	// Mock marketplace config API response with LAOS collection
+	const laosMarketplaceConfigResponse = {
+		marketplace: {
+			projectId: 1,
+			settings: {
+				style: {},
+				publisherId: 'test-publisher',
+				title: 'Test Marketplace',
+				socials: {
+					twitter: '',
+					discord: '',
+					website: '',
+					tiktok: '',
+					instagram: '',
+					youtube: '',
+				},
+				faviconUrl: '',
+				walletOptions: {
+					walletType: 'UNIVERSAL',
+					oidcIssuers: {},
+					connectors: [],
+					includeEIP6963Wallets: false,
+				},
+				logoUrl: '',
+				fontUrl: '',
+			},
+			market: {
+				enabled: true,
+				title: 'Test Market',
+				bannerUrl: 'https://example.com/banner.png',
+				ogImage: 'https://example.com/og.png',
+			},
+			shop: {
+				enabled: false,
+				title: '',
+				bannerUrl: '',
+				ogImage: '',
+			},
+		},
+		marketCollections: [
+			{
+				id: 1,
+				projectId: 1,
+				chainId: 11155111,
+				itemsAddress: '0x1234567890123456789012345678901234567890',
+				contractType: ContractType.LAOS_ERC_721,
+				bannerUrl: 'https://example.com/banner.png',
+				feePercentage: 0,
+				currencyOptions: [],
+				destinationMarketplace: 'sequence_marketplace_v2',
+			},
+			{
+				id: 2,
+				projectId: 1,
+				chainId: 11155111,
+				itemsAddress: '0x9876543210987654321098765432109876543210',
+				contractType: ContractType.ERC721,
+				bannerUrl: 'https://example.com/banner2.png',
+				feePercentage: 0,
+				currencyOptions: [],
+				destinationMarketplace: 'sequence_marketplace_v2',
+			},
+		],
+		shopCollections: [],
+	};
+
+	// Setup handlers for LAOS and marketplace config
+	afterEach(() => {
+		server.resetHandlers();
+	});
+
+	it('should use LAOS API when collection is LAOS_ERC_721', async () => {
+		// Add LAOS handlers and marketplace config handler
+		server.use(
+			...laosHandlers,
+			http.post('*/rpc/MarketplaceService/LookupMarketplace', () => {
+				return HttpResponse.json(laosMarketplaceConfigResponse);
+			}),
+		);
+
+		const { result } = renderHook(() => useBalanceOfCollectible(defaultArgs));
+
+		// Initially loading
+		expect(result.current.isLoading).toBe(true);
+
+		// Wait for the query to complete
+		await waitFor(() => {
+			expect(result.current.isSuccess).toBe(true);
+		});
+
+		// Should return LAOS API response (first balance)
+		expect(result.current.data).toEqual(mockTokenBalancesResponse.balances[0]);
+		expect(result.current.data?.balance).toBe('5');
+		expect(result.current.data?.contractInfo?.type).toBe('LAOS-ERC-721');
+	});
+
+	it('should use indexer API when collection is regular ERC_721', async () => {
+		const regularCollectionArgs = {
+			...defaultArgs,
+			collectionAddress:
+				'0x9876543210987654321098765432109876543210' as `0x${string}`,
+		};
+
+		server.use(
+			http.post('*/rpc/MarketplaceService/LookupMarketplace', () => {
+				return HttpResponse.json(laosMarketplaceConfigResponse);
+			}),
+			http.post(mockIndexerEndpoint('GetTokenBalances'), () => {
+				return HttpResponse.json({
+					page: { page: 1, pageSize: 10, more: false },
+					balances: [mockTokenBalance],
+				});
+			}),
+		);
+
+		const { result } = renderHook(() =>
+			useBalanceOfCollectible(regularCollectionArgs),
+		);
+
+		await waitFor(() => {
+			expect(result.current.isSuccess).toBe(true);
+		});
+
+		// Should return indexer API response
+		expect(result.current.data).toEqual(mockTokenBalance);
+		expect(result.current.data?.contractInfo?.type).toBe('ERC721');
+	});
+
+	it('should handle LAOS API errors gracefully', async () => {
+		const errorArgs = {
+			...defaultArgs,
+			userAddress:
+				'0x0000000000000000000000000000000000000001' as `0x${string}`, // Special address for 500 error
+		};
+
+		server.use(
+			...laosHandlers,
+			http.post('*/rpc/MarketplaceService/LookupMarketplace', () => {
+				return HttpResponse.json(laosMarketplaceConfigResponse);
+			}),
+		);
+
+		const { result } = renderHook(() => useBalanceOfCollectible(errorArgs));
+
+		await waitFor(() => {
+			expect(result.current.isError).toBe(true);
+		});
+
+		expect(result.current.error).toBeDefined();
+	});
+
+	it('should return null when LAOS API returns empty balances', async () => {
+		const emptyBalanceArgs = {
+			...defaultArgs,
+			userAddress:
+				'0x0000000000000000000000000000000000000003' as `0x${string}`, // Special address for empty response
+		};
+
+		server.use(
+			...laosHandlers,
+			http.post('*/rpc/MarketplaceService/LookupMarketplace', () => {
+				return HttpResponse.json(laosMarketplaceConfigResponse);
+			}),
+		);
+
+		const { result } = renderHook(() =>
+			useBalanceOfCollectible(emptyBalanceArgs),
+		);
+
+		await waitFor(() => {
+			expect(result.current.isSuccess).toBe(true);
+		});
+
+		expect(result.current.data).toBeNull();
+	});
+
+	it('should auto-detect LAOS from marketplace config', async () => {
+		server.use(
+			...laosHandlers,
+			http.post('*/rpc/MarketplaceService/LookupMarketplace', () => {
+				return HttpResponse.json(laosMarketplaceConfigResponse);
+			}),
+		);
+
+		const { result } = renderHook(() => useBalanceOfCollectible(defaultArgs));
+
+		await waitFor(() => {
+			expect(result.current.isSuccess).toBe(true);
+		});
+
+		// Verify it used LAOS API (returns LAOS-specific data structure)
+		expect(result.current.data?.contractInfo?.type).toBe('LAOS-ERC-721');
+		expect(result.current.data?.tokenMetadata).toBeDefined();
+	});
+
+	it('should fallback to indexer when marketplace config is unavailable', async () => {
+		// No marketplace config handler - should fallback to indexer
+		server.use(
+			http.post(mockIndexerEndpoint('GetTokenBalances'), () => {
+				return HttpResponse.json({
+					page: { page: 1, pageSize: 10, more: false },
+					balances: [mockTokenBalance],
+				});
+			}),
+		);
+
+		const { result } = renderHook(() => useBalanceOfCollectible(defaultArgs));
+
+		await waitFor(() => {
+			expect(result.current.isSuccess).toBe(true);
+		});
+
+		// Should use indexer since no marketplace config to determine LAOS
+		expect(result.current.data).toEqual(mockTokenBalance);
+		expect(result.current.data?.contractInfo?.type).toBe('ERC721');
+	});
+
+	it('should handle collection not found in marketplace config', async () => {
+		const unknownCollectionArgs = {
+			...defaultArgs,
+			collectionAddress:
+				'0x0000000000000000000000000000000000000999' as `0x${string}`, // Unknown collection
+		};
+
+		server.use(
+			http.post('*/rpc/MarketplaceService/LookupMarketplace', () => {
+				return HttpResponse.json(laosMarketplaceConfigResponse);
+			}),
+			http.post(mockIndexerEndpoint('GetTokenBalances'), () => {
+				return HttpResponse.json({
+					page: { page: 1, pageSize: 10, more: false },
+					balances: [mockTokenBalance],
+				});
+			}),
+		);
+
+		const { result } = renderHook(() =>
+			useBalanceOfCollectible(unknownCollectionArgs),
+		);
+
+		await waitFor(() => {
+			expect(result.current.isSuccess).toBe(true);
+		});
+
+		// Should fallback to indexer when collection not found in config
+		expect(result.current.data).toEqual(mockTokenBalance);
+		expect(result.current.data?.contractInfo?.type).toBe('ERC721');
+	});
+
+	it('should respect enabled query option for LAOS collections', () => {
+		server.use(
+			...laosHandlers,
+			http.post('*/rpc/MarketplaceService/LookupMarketplace', () => {
+				return HttpResponse.json(laosMarketplaceConfigResponse);
+			}),
+		);
+
+		const { result } = renderHook(() =>
+			useBalanceOfCollectible({
+				...defaultArgs,
+				query: {
+					enabled: false,
+				},
+			}),
+		);
+
+		expect(result.current.isLoading).toBe(false);
+		expect(result.current.data).toBeUndefined();
+	});
+
+	it('should handle LAOS metadata correctly', async () => {
+		server.use(
+			...laosHandlers,
+			http.post('*/rpc/MarketplaceService/LookupMarketplace', () => {
+				return HttpResponse.json(laosMarketplaceConfigResponse);
+			}),
+		);
+
+		const { result } = renderHook(() => useBalanceOfCollectible(defaultArgs));
+
+		await waitFor(() => {
+			expect(result.current.isSuccess).toBe(true);
+		});
+
+		const balance = result.current.data;
+		expect(balance?.tokenMetadata).toBeDefined();
+		expect(balance?.tokenMetadata?.name).toBe('Test Token 1');
+		expect(balance?.tokenMetadata?.description).toBe(
+			'A test token for LAOS testing',
+		);
+		expect(balance?.tokenMetadata?.image).toBe(
+			'https://example.com/token1.png',
+		);
+		expect(balance?.tokenMetadata?.attributes).toEqual([
+			{
+				trait_type: 'Rarity',
+				value: 'Common',
+			},
+		]);
+	});
+
+	it('should pass correct parameters to LAOS API', async () => {
+		let capturedRequestBody: Record<string, unknown> = {};
+
+		server.use(
+			http.post('*/rpc/MarketplaceService/LookupMarketplace', () => {
+				return HttpResponse.json(laosMarketplaceConfigResponse);
+			}),
+			http.post(
+				'https://extensions.api.laosnetwork.io/token/GetTokenBalances',
+				async ({ request }) => {
+					const body = await request.json();
+					capturedRequestBody = body as Record<string, unknown>;
+					return HttpResponse.json(mockTokenBalancesResponse);
+				},
+			),
+		);
+
+		const { result } = renderHook(() => useBalanceOfCollectible(defaultArgs));
+
+		await waitFor(() => {
+			expect(result.current.isSuccess).toBe(true);
+		});
+
+		// Verify LAOS API was called with correct parameters
+		expect(capturedRequestBody).toMatchInlineSnapshot(`
+			{
+			  "accountAddress": "0xuser1234567890123456789012345678901234567890",
+			  "chainId": "11155111",
+			  "contractAddress": "0x1234567890123456789012345678901234567890",
+			  "includeMetadata": true,
+			  "page": {
+			    "sort": [
+			      {
+			        "column": "CREATED_AT",
+			        "order": "DESC",
+			      },
+			    ],
+			  },
+			}
+		`);
+	});
+});

package/src/react/hooks/{__tests__ → data/collectibles}/useBalanceOfCollectible.test.tsx

@@ -5,8 +5,8 @@ import { describe, expect, it } from 'vitest';
 import {
 	mockIndexerEndpoint,
 	mockTokenBalance,
-} from '../../_internal/api/__mocks__/indexer.msw';
-import { useBalanceOfCollectible } from '../useBalanceOfCollectible';
+} from '../../../_internal/api/__mocks__/indexer.msw';
+import { useBalanceOfCollectible } from './useBalanceOfCollectible';
 
 describe('useBalanceOfCollectible', () => {
 	const defaultArgs = {

package/src/react/hooks/{useBalanceOfCollectible.tsx → data/collectibles/useBalanceOfCollectible.tsx}

@@ -1,11 +1,11 @@
 import { useQuery } from '@tanstack/react-query';
-import { ContractType } from '../_internal';
+import { ContractType } from '../../../_internal';
 import {
 	balanceOfCollectibleOptions,
 	type UseBalanceOfCollectibleArgs,
-} from '../queries/balanceOfCollectible';
-import { useConfig } from './useConfig';
-import { useMarketplaceConfig } from './useMarketplaceConfig';
+} from '../../../queries/balanceOfCollectible';
+import { useConfig } from '../../config/useConfig';
+import { useMarketplaceConfig } from '../../config/useMarketplaceConfig';
 
 /**
  * Hook to fetch the balance of a specific collectible for a user

package/src/react/hooks/{__tests__ → data/collectibles}/useCollectible.test.tsx

@@ -5,9 +5,9 @@ import { describe, expect, it } from 'vitest';
 import {
 	mockMetadataEndpoint,
 	mockTokenMetadata,
-} from '../../_internal/api/__mocks__/metadata.msw';
-import type { UseCollectibleParams } from '../useCollectible';
-import { useCollectible } from '../useCollectible';
+} from '../../../_internal/api/__mocks__/metadata.msw';
+import type { UseCollectibleParams } from './useCollectible';
+import { useCollectible } from './useCollectible';
 
 describe('useCollectible', () => {
 	const defaultArgs: UseCollectibleParams = {

package/src/react/hooks/{useCollectible.tsx → data/collectibles/useCollectible.tsx}

@@ -1,13 +1,13 @@
 'use client';
 
 import { useQuery } from '@tanstack/react-query';
-import type { Optional } from '../_internal';
+import type { Optional } from '../../../_internal';
 import {
 	type CollectibleQueryOptions,
 	collectibleQueryOptions,
 	type FetchCollectibleParams,
-} from '../queries/collectible';
-import { useConfig } from './useConfig';
+} from '../../../queries/collectible';
+import { useConfig } from '../../config/useConfig';
 
 export type UseCollectibleParams = Optional<CollectibleQueryOptions, 'config'>;
 

package/src/react/hooks/{__tests__ → data/collectibles}/useCountOfCollectables.test.tsx

@@ -2,10 +2,10 @@ import { renderHook, server, waitFor } from '@test';
 import { HttpResponse, http } from 'msw';
 import { zeroAddress } from 'viem';
 import { describe, expect, it } from 'vitest';
-import { OrderSide } from '../../_internal';
-import { mockMarketplaceEndpoint } from '../../_internal/api/__mocks__/marketplace.msw';
-import type { UseCountOfCollectablesParams } from '../useCountOfCollectables';
-import { useCountOfCollectables } from '../useCountOfCollectables';
+import { mockMarketplaceEndpoint } from '../../../_internal/api/__mocks__/marketplace.msw';
+import { OrderSide } from '../../../_internal/api/marketplace.gen';
+import type { UseCountOfCollectablesParams } from './useCountOfCollectables';
+import { useCountOfCollectables } from './useCountOfCollectables';
 
 describe('useCountOfCollectables', () => {
 	const defaultArgs: UseCountOfCollectablesParams = {

package/src/react/hooks/{useCountOfCollectables.tsx → data/collectibles/useCountOfCollectables.tsx}

@@ -1,13 +1,13 @@
 'use client';
 
 import { useQuery } from '@tanstack/react-query';
-import type { Optional } from '../_internal';
+import type { Optional } from '../../../_internal';
 import {
 	type CountOfCollectablesQueryOptions,
 	countOfCollectablesQueryOptions,
 	type FetchCountOfCollectablesParams,
-} from '../queries/countOfCollectables';
-import { useConfig } from './useConfig';
+} from '../../../queries/countOfCollectables';
+import { useConfig } from '../../config/useConfig';
 
 export type UseCountOfCollectablesParams = Optional<
 	CountOfCollectablesQueryOptions,

package/src/react/hooks/{__tests__ → data/collectibles}/useListCollectibleActivities.test.tsx

@@ -5,9 +5,9 @@ import { describe, expect, it } from 'vitest';
 import {
 	mockActivity,
 	mockMarketplaceEndpoint,
-} from '../../_internal/api/__mocks__/marketplace.msw';
-import type { UseListCollectibleActivitiesParams } from '../useListCollectibleActivities';
-import { useListCollectibleActivities } from '../useListCollectibleActivities';
+} from '../../../_internal/api/__mocks__/marketplace.msw';
+import type { UseListCollectibleActivitiesParams } from './useListCollectibleActivities';
+import { useListCollectibleActivities } from './useListCollectibleActivities';
 
 describe('useListCollectibleActivities', () => {
 	const defaultArgs: UseListCollectibleActivitiesParams = {

package/src/react/hooks/{useListCollectibleActivities.tsx → data/collectibles/useListCollectibleActivities.tsx}

@@ -1,14 +1,14 @@
 'use client';
 
 import { useQuery } from '@tanstack/react-query';
-import type { Optional } from '../_internal';
+import type { Optional } from '../../../_internal';
 import {
 	type FetchListCollectibleActivitiesParams,
 	type fetchListCollectibleActivities,
 	type ListCollectibleActivitiesQueryOptions,
 	listCollectibleActivitiesQueryOptions,
-} from '../queries/listCollectibleActivities';
-import { useConfig } from './useConfig';
+} from '../../../queries/listCollectibleActivities';
+import { useConfig } from '../../config/useConfig';
 
 export type UseListCollectibleActivitiesParams = Optional<
 	ListCollectibleActivitiesQueryOptions,

package/src/react/hooks/{__tests__ → data/collectibles}/useListCollectibles.test.tsx

@@ -2,18 +2,17 @@ import { renderHook, server, waitFor } from '@test';
 import { HttpResponse, http } from 'msw';
 import { zeroAddress } from 'viem';
 import { describe, expect, it } from 'vitest';
-import type { ListCollectiblesArgs } from '../../_internal';
+import type { ListCollectiblesArgs } from '../../../_internal';
 import {
 	mockCollectibleOrder,
 	mockMarketplaceEndpoint,
-} from '../../_internal/api/__mocks__/marketplace.msw';
+} from '../../../_internal/api/__mocks__/marketplace.msw';
 import {
 	MarketplaceKind,
 	OrderSide,
-} from '../../_internal/api/marketplace.gen';
-
-import type { UseListCollectiblesParams } from '../useListCollectibles';
-import { useListCollectibles } from '../useListCollectibles';
+} from '../../../_internal/api/marketplace.gen';
+import type { UseListCollectiblesParams } from './useListCollectibles';
+import { useListCollectibles } from './useListCollectibles';
 
 describe('useListCollectibles', () => {
 	const defaultArgs: UseListCollectiblesParams = {

package/src/react/hooks/{useListCollectibles.tsx → data/collectibles/useListCollectibles.tsx}

@@ -1,13 +1,13 @@
 'use client';
 
 import { useInfiniteQuery } from '@tanstack/react-query';
-import type { Optional } from '../_internal';
+import type { Optional } from '../../../_internal';
 import {
 	type FetchListCollectiblesParams,
 	type ListCollectiblesQueryOptions,
 	listCollectiblesQueryOptions,
-} from '../queries/listCollectibles';
-import { useConfig } from './useConfig';
+} from '../../../queries/listCollectibles';
+import { useConfig } from '../../config/useConfig';
 
 export type UseListCollectiblesParams = Optional<
 	ListCollectiblesQueryOptions,

package/src/react/hooks/{__tests__ → data/collectibles}/useListCollectiblesPaginated.test.tsx

@@ -6,10 +6,10 @@ import { describe, expect, it } from 'vitest';
 import {
 	mockCollectibleOrder,
 	mockMarketplaceEndpoint,
-} from '../../_internal/api/__mocks__/marketplace.msw';
-import { OrderSide } from '../../_internal/api/marketplace.gen';
-import type { UseListCollectiblesPaginatedParams } from '../useListCollectiblesPaginated';
-import { useListCollectiblesPaginated } from '../useListCollectiblesPaginated';
+} from '../../../_internal/api/__mocks__/marketplace.msw';
+import { OrderSide } from '../../../_internal/api/marketplace.gen';
+import type { UseListCollectiblesPaginatedParams } from './useListCollectiblesPaginated';
+import { useListCollectiblesPaginated } from './useListCollectiblesPaginated';
 
 describe('useListCollectiblesPaginated', () => {
 	const defaultArgs: UseListCollectiblesPaginatedParams = {

package/src/react/hooks/{useListCollectiblesPaginated.tsx → data/collectibles/useListCollectiblesPaginated.tsx}

@@ -1,14 +1,14 @@
 'use client';
 
 import { useQuery } from '@tanstack/react-query';
-import type { Optional } from '../_internal';
+import type { Optional } from '../../../_internal';
 import {
 	type FetchListCollectiblesPaginatedParams,
 	type fetchListCollectiblesPaginated,
 	type ListCollectiblesPaginatedQueryOptions,
 	listCollectiblesPaginatedQueryOptions,
-} from '../queries/listCollectiblesPaginated';
-import { useConfig } from './useConfig';
+} from '../../../queries/listCollectiblesPaginated';
+import { useConfig } from '../../config/useConfig';
 
 export type UseListCollectiblesPaginatedParams = Optional<
 	ListCollectiblesPaginatedQueryOptions,

package/src/react/hooks/{__tests__ → data/collections}/__snapshots__/useListCollections.test.tsx.snap

@@ -50,6 +50,7 @@ exports[`useListCollections > should fetch collections successfully 1`] = `
     "logoURI": "https://example.com/logo.png",
     "marketplaceType": "market",
     "name": "Mock Collection",
+    "private": false,
     "projectId": 1,
     "source": "https://example.com/source",
     "status": "AVAILABLE",
@@ -109,6 +110,7 @@ exports[`useListCollections > should fetch collections successfully 1`] = `
     "logoURI": "https://example.com/logo.png",
     "marketplaceType": "market",
     "name": "Mock Collection",
+    "private": false,
     "projectId": 1,
     "source": "https://example.com/source",
     "status": "AVAILABLE",
@@ -122,6 +124,7 @@ exports[`useListCollections > should fetch collections successfully 1`] = `
     "bytecodeHash": "0x1234567890",
     "chainId": 1,
     "createdAt": "2025-03-16T13:04:16.098Z",
+    "customTokenIds": [],
     "deployed": true,
     "extensions": {
       "blacklist": false,
@@ -144,6 +147,7 @@ exports[`useListCollections > should fetch collections successfully 1`] = `
     "logoURI": "https://example.com/logo.png",
     "marketplaceType": "shop",
     "name": "Mock Collection",
+    "private": false,
     "projectId": 1,
     "saleAddress": "0x0000000000000000000000000000000000000000",
     "saleBannerUrl": "https://example.com/shop-sale-banner.png",
@@ -164,6 +168,7 @@ exports[`useListCollections > should fetch collections successfully 1`] = `
     "bytecodeHash": "0x1234567890",
     "chainId": 137,
     "createdAt": "2025-03-16T13:04:16.098Z",
+    "customTokenIds": [],
     "deployed": true,
     "extensions": {
       "blacklist": false,
@@ -186,6 +191,7 @@ exports[`useListCollections > should fetch collections successfully 1`] = `
     "logoURI": "https://example.com/logo.png",
     "marketplaceType": "shop",
     "name": "Mock Collection",
+    "private": false,
     "projectId": 1,
     "saleAddress": "0x1234567890123456789012345678901234567890",
     "saleBannerUrl": "https://example.com/polygon-shop-sale-banner.png",
@@ -211,6 +217,7 @@ exports[`useListCollections > should handle empty collections 1`] = `
     "bytecodeHash": "0x1234567890",
     "chainId": 1,
     "createdAt": "2025-03-16T13:04:16.098Z",
+    "customTokenIds": [],
     "deployed": true,
     "extensions": {
       "blacklist": false,
@@ -233,6 +240,7 @@ exports[`useListCollections > should handle empty collections 1`] = `
     "logoURI": "https://example.com/logo.png",
     "marketplaceType": "shop",
     "name": "Mock Collection",
+    "private": false,
     "projectId": 1,
     "saleAddress": "0x0000000000000000000000000000000000000000",
     "saleBannerUrl": "https://example.com/shop-sale-banner.png",
@@ -253,6 +261,7 @@ exports[`useListCollections > should handle empty collections 1`] = `
     "bytecodeHash": "0x1234567890",
     "chainId": 137,
     "createdAt": "2025-03-16T13:04:16.098Z",
+    "customTokenIds": [],
     "deployed": true,
     "extensions": {
       "blacklist": false,
@@ -275,6 +284,7 @@ exports[`useListCollections > should handle empty collections 1`] = `
     "logoURI": "https://example.com/logo.png",
     "marketplaceType": "shop",
     "name": "Mock Collection",
+    "private": false,
     "projectId": 1,
     "saleAddress": "0x1234567890123456789012345678901234567890",
     "saleBannerUrl": "https://example.com/polygon-shop-sale-banner.png",

package/src/react/hooks/data/collections/index.ts

@@ -0,0 +1,6 @@
+export * from './useCollection';
+export * from './useCollectionBalanceDetails';
+export * from './useCollectionDetails';
+export * from './useCollectionDetailsPolling';
+export * from './useListCollectionActivities';
+export * from './useListCollections';