@0xsequence/marketplace-sdk 1.1.1 → 1.2.1

package/src/react/hooks/data/collectibles/useListCollectibles.tsx

@@ -18,14 +18,13 @@ export type UseListCollectiblesParams = Optional<
  * Hook to fetch a list of collectibles with infinite pagination support
  *
  * Fetches collectibles from the marketplace with support for filtering, pagination,
- * and special handling for shop marketplace types and LAOS721 contracts.
+ * and special handling for shop marketplace types.
  *
  * @param params - Configuration parameters
  * @param params.chainId - The chain ID (must be number, e.g., 1 for Ethereum, 137 for Polygon)
  * @param params.collectionAddress - The collection contract address
  * @param params.side - Order side (listing or bid)
  * @param params.filter - Optional filtering parameters
- * @param params.isLaos721 - Whether the collection is a LAOS721 contract
  * @param params.marketplaceType - Type of marketplace (shop, etc.)
  * @param params.query - Optional React Query configuration
  *
@@ -55,20 +54,6 @@ export type UseListCollectiblesParams = Optional<
  *   }
  * })
  * ```
- *
- * @example
- * For LAOS721 collections:
- * ```typescript
- * const { data } = useListCollectibles({
- *   chainId: 137,
- *   collectionAddress: '0x...',
- *   side: OrderSide.listing,
- *   isLaos721: true,
- *   filter: {
- *     inAccounts: ['0x...']
- *   }
- * })
- * ```
  */
 export function useListCollectibles(params: UseListCollectiblesParams) {
 	const defaultConfig = useConfig();

package/src/react/hooks/data/collectibles/useTokenBalances.tsx

@@ -1,11 +1,9 @@
 import { useQuery } from '@tanstack/react-query';
-import { ContractType } from '../../../_internal';
 import {
 	tokenBalancesOptions,
 	type UseTokenBalancesArgs,
 } from '../../../queries/collectibles/tokenBalances';
 import { useConfig } from '../../config/useConfig';
-import { useMarketplaceConfig } from '../../config/useMarketplaceConfig';
 
 /**
  * Hook to fetch all token balances for a user in a collection
@@ -28,18 +26,11 @@ import { useMarketplaceConfig } from '../../config/useMarketplaceConfig';
  */
 export function useTokenBalances(args: UseTokenBalancesArgs) {
 	const config = useConfig();
-	const { data: marketplaceConfig } = useMarketplaceConfig();
-
-	const collection = marketplaceConfig?.market.collections.find(
-		(collection) => collection.itemsAddress === args.collectionAddress,
-	);
-	const isLaos721 = collection?.contractType === ContractType.LAOS_ERC_721;
 
 	return useQuery(
 		tokenBalancesOptions(
 			{
 				...args,
-				isLaos721,
 			},
 			config,
 		),

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

@@ -1,4 +1,6 @@
 export * from './useCollection';
+export * from './useCollectionActiveListingsCurrencies';
+export * from './useCollectionActiveOffersCurrencies';
 export * from './useCollectionBalanceDetails';
 export * from './useCollectionDetails';
 export * from './useCollectionDetailsPolling';

package/src/react/hooks/data/collections/useCollectionActiveListingsCurrencies.test.tsx

@@ -0,0 +1,112 @@
+import { renderHook, server, waitFor } from '@test';
+import { HttpResponse, http } from 'msw';
+import { zeroAddress } from 'viem';
+import { describe, expect, it } from 'vitest';
+import {
+	mockCurrencies,
+	mockMarketplaceEndpoint,
+} from '../../../_internal/api/__mocks__/marketplace.msw';
+import type { UseCollectionActiveListingsCurrenciesParams } from './useCollectionActiveListingsCurrencies';
+import { useCollectionActiveListingsCurrencies } from './useCollectionActiveListingsCurrencies';
+
+describe('useCollectionActiveListingsCurrencies', () => {
+	const defaultArgs: UseCollectionActiveListingsCurrenciesParams = {
+		chainId: 1,
+		collectionAddress: zeroAddress,
+	};
+
+	it('should fetch active listings currencies data successfully', async () => {
+		const { result } = renderHook(() =>
+			useCollectionActiveListingsCurrencies(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).toEqual(mockCurrencies);
+		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('GetCollectionActiveListingsCurrencies'),
+				() => {
+					return HttpResponse.json(
+						{
+							error: { message: 'Failed to fetch active listings currencies' },
+						},
+						{ status: 500 },
+					);
+				},
+			),
+		);
+
+		const { result } = renderHook(() =>
+			useCollectionActiveListingsCurrencies(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(() =>
+			useCollectionActiveListingsCurrencies(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}`,
+		};
+
+		rerender(() => useCollectionActiveListingsCurrencies(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).toBeDefined();
+		expect(result.current.isSuccess).toBe(true);
+	});
+
+	it('should handle undefined query params', async () => {
+		const argsWithoutQuery: UseCollectionActiveListingsCurrenciesParams = {
+			chainId: 1,
+			collectionAddress: zeroAddress,
+			query: {},
+		};
+
+		const { result } = renderHook(() =>
+			useCollectionActiveListingsCurrencies(argsWithoutQuery),
+		);
+
+		await waitFor(() => {
+			expect(result.current.isLoading).toBe(false);
+		});
+
+		expect(result.current.data).toBeDefined();
+		expect(result.current.error).toBeNull();
+	});
+});

package/src/react/hooks/data/collections/useCollectionActiveListingsCurrencies.tsx

@@ -0,0 +1,74 @@
+'use client';
+
+import { useQuery } from '@tanstack/react-query';
+import type { Optional } from '../../../_internal';
+import {
+	type CollectionActiveListingsCurrenciesQueryOptions,
+	collectionActiveListingsCurrenciesQueryOptions,
+	type FetchCollectionActiveListingsCurrenciesParams,
+} from '../../../queries/collections/activeListingsCurrencies';
+import { useConfig } from '../../config/useConfig';
+
+export type UseCollectionActiveListingsCurrenciesParams = Optional<
+	CollectionActiveListingsCurrenciesQueryOptions,
+	'config'
+>;
+
+/**
+ * Hook to fetch the active listings currencies for a collection
+ *
+ * Retrieves all currencies that are currently being used in active listings
+ * for a specific collection from the marketplace.
+ *
+ * @param params - Configuration parameters
+ * @param params.chainId - The chain ID (must be number, e.g., 1 for Ethereum, 137 for Polygon)
+ * @param params.collectionAddress - The collection contract address
+ * @param params.query - Optional React Query configuration
+ *
+ * @returns Query result containing the array of currencies used in active listings
+ *
+ * @example
+ * Basic usage:
+ * ```typescript
+ * const { data, isLoading } = useCollectionActiveListingsCurrencies({
+ *   chainId: 137,
+ *   collectionAddress: '0x...'
+ * })
+ * ```
+ *
+ * @example
+ * With custom query options:
+ * ```typescript
+ * const { data, isLoading } = useCollectionActiveListingsCurrencies({
+ *   chainId: 1,
+ *   collectionAddress: '0x...',
+ *   query: {
+ *     refetchInterval: 30000,
+ *     enabled: hasCollectionAddress
+ *   }
+ * })
+ * ```
+ */
+export function useCollectionActiveListingsCurrencies(
+	params: UseCollectionActiveListingsCurrenciesParams,
+) {
+	const defaultConfig = useConfig();
+
+	const { config = defaultConfig, ...rest } = params;
+
+	const queryOptions = collectionActiveListingsCurrenciesQueryOptions({
+		config,
+		...rest,
+	});
+
+	return useQuery({
+		...queryOptions,
+	});
+}
+
+export { collectionActiveListingsCurrenciesQueryOptions };
+
+export type {
+	FetchCollectionActiveListingsCurrenciesParams,
+	CollectionActiveListingsCurrenciesQueryOptions,
+};

package/src/react/hooks/data/collections/useCollectionActiveOffersCurrencies.test.tsx

@@ -0,0 +1,110 @@
+import { renderHook, server, waitFor } from '@test';
+import { HttpResponse, http } from 'msw';
+import { zeroAddress } from 'viem';
+import { describe, expect, it } from 'vitest';
+import {
+	mockCurrencies,
+	mockMarketplaceEndpoint,
+} from '../../../_internal/api/__mocks__/marketplace.msw';
+import type { UseCollectionActiveOffersCurrenciesParams } from './useCollectionActiveOffersCurrencies';
+import { useCollectionActiveOffersCurrencies } from './useCollectionActiveOffersCurrencies';
+
+describe('useCollectionActiveOffersCurrencies', () => {
+	const defaultArgs: UseCollectionActiveOffersCurrenciesParams = {
+		chainId: 1,
+		collectionAddress: zeroAddress,
+	};
+
+	it('should fetch active offers currencies data successfully', async () => {
+		const { result } = renderHook(() =>
+			useCollectionActiveOffersCurrencies(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).toEqual(mockCurrencies);
+		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('GetCollectionActiveOffersCurrencies'),
+				() => {
+					return HttpResponse.json(
+						{ error: { message: 'Failed to fetch active offers currencies' } },
+						{ status: 500 },
+					);
+				},
+			),
+		);
+
+		const { result } = renderHook(() =>
+			useCollectionActiveOffersCurrencies(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(() =>
+			useCollectionActiveOffersCurrencies(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}`,
+		};
+
+		rerender(() => useCollectionActiveOffersCurrencies(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).toBeDefined();
+		expect(result.current.isSuccess).toBe(true);
+	});
+
+	it('should handle undefined query params', async () => {
+		const argsWithoutQuery: UseCollectionActiveOffersCurrenciesParams = {
+			chainId: 1,
+			collectionAddress: zeroAddress,
+			query: {},
+		};
+
+		const { result } = renderHook(() =>
+			useCollectionActiveOffersCurrencies(argsWithoutQuery),
+		);
+
+		await waitFor(() => {
+			expect(result.current.isLoading).toBe(false);
+		});
+
+		expect(result.current.data).toBeDefined();
+		expect(result.current.error).toBeNull();
+	});
+});

package/src/react/hooks/data/collections/useCollectionActiveOffersCurrencies.tsx

@@ -0,0 +1,74 @@
+'use client';
+
+import { useQuery } from '@tanstack/react-query';
+import type { Optional } from '../../../_internal';
+import {
+	type CollectionActiveOffersCurrenciesQueryOptions,
+	collectionActiveOffersCurrenciesQueryOptions,
+	type FetchCollectionActiveOffersCurrenciesParams,
+} from '../../../queries/collections/activeOffersCurrencies';
+import { useConfig } from '../../config/useConfig';
+
+export type UseCollectionActiveOffersCurrenciesParams = Optional<
+	CollectionActiveOffersCurrenciesQueryOptions,
+	'config'
+>;
+
+/**
+ * Hook to fetch the active offers currencies for a collection
+ *
+ * Retrieves all currencies that are currently being used in active offers
+ * for a specific collection from the marketplace.
+ *
+ * @param params - Configuration parameters
+ * @param params.chainId - The chain ID (must be number, e.g., 1 for Ethereum, 137 for Polygon)
+ * @param params.collectionAddress - The collection contract address
+ * @param params.query - Optional React Query configuration
+ *
+ * @returns Query result containing the array of currencies used in active offers
+ *
+ * @example
+ * Basic usage:
+ * ```typescript
+ * const { data, isLoading } = useCollectionActiveOffersCurrencies({
+ *   chainId: 137,
+ *   collectionAddress: '0x...'
+ * })
+ * ```
+ *
+ * @example
+ * With custom query options:
+ * ```typescript
+ * const { data, isLoading } = useCollectionActiveOffersCurrencies({
+ *   chainId: 1,
+ *   collectionAddress: '0x...',
+ *   query: {
+ *     refetchInterval: 30000,
+ *     enabled: hasCollectionAddress
+ *   }
+ * })
+ * ```
+ */
+export function useCollectionActiveOffersCurrencies(
+	params: UseCollectionActiveOffersCurrenciesParams,
+) {
+	const defaultConfig = useConfig();
+
+	const { config = defaultConfig, ...rest } = params;
+
+	const queryOptions = collectionActiveOffersCurrenciesQueryOptions({
+		config,
+		...rest,
+	});
+
+	return useQuery({
+		...queryOptions,
+	});
+}
+
+export { collectionActiveOffersCurrenciesQueryOptions };
+
+export type {
+	FetchCollectionActiveOffersCurrenciesParams,
+	CollectionActiveOffersCurrenciesQueryOptions,
+};

package/src/react/hooks/data/inventory/useInventory.tsx

@@ -1,21 +1,12 @@
 import { useQuery } from '@tanstack/react-query';
-import { ContractType } from '../../../_internal';
 import {
 	inventoryOptions,
 	type UseInventoryArgs,
 } from '../../../queries/inventory/inventory';
 import { useConfig } from '../../config/useConfig';
-import { useMarketplaceConfig } from '../../config/useMarketplaceConfig';
 
 export function useInventory(args: UseInventoryArgs) {
 	const config = useConfig();
-	const { data: marketplaceConfig } = useMarketplaceConfig();
 
-	const isLaos721 =
-		marketplaceConfig?.market?.collections?.find(
-			(c) =>
-				c.itemsAddress === args.collectionAddress && c.chainId === args.chainId,
-		)?.contractType === ContractType.LAOS_ERC_721;
-
-	return useQuery(inventoryOptions({ ...args, isLaos721 }, config));
+	return useQuery(inventoryOptions({ ...args }, config));
 }

package/src/react/hooks/data/market/useMarketCurrencies.test.tsx

@@ -49,7 +49,30 @@ describe('useMarketCurrencies', () => {
 		);
 	});
 
-	it('should filter currencies by collection address', async () => {
+	it('should filter currencies by collection address for non-OpenSea collections', async () => {
+		const args = {
+			...defaultArgs,
+			collectionAddress: mockConfig.marketCollections[0]
+				.itemsAddress as Address,
+		} satisfies Parameters<typeof useMarketCurrencies>[0];
+
+		const { result } = renderHook(() => useMarketCurrencies(args));
+
+		await waitFor(() => {
+			expect(result.current.isLoading).toBe(false);
+		});
+
+		const currencyAddresses = result.current.data?.map(
+			(c) => c.contractAddress,
+		);
+
+		// For non-OpenSea collections, currencies should be filtered by currencyOptions
+		expect(currencyAddresses).toEqual(
+			mockConfig.marketCollections[0].currencyOptions,
+		);
+	});
+
+	it('should not filter currencies by collection address for OpenSea collections', async () => {
 		const args = {
 			...defaultArgs,
 			collectionAddress: mockConfig.marketCollections[1]
@@ -65,8 +88,12 @@ describe('useMarketCurrencies', () => {
 		const currencyAddresses = result.current.data?.map(
 			(c) => c.contractAddress,
 		);
+
+		// For OpenSea collections, currencies are not filtered by currencyOptions
+		// Instead, all currencies are returned and filtering happens at the UI level
+		// based on openseaListing/openseaOffer flags
 		expect(currencyAddresses).toEqual(
-			mockConfig.marketCollections[1].currencyOptions,
+			mockCurrencies.map((c) => c.contractAddress),
 		);
 	});
 
@@ -161,6 +188,8 @@ describe('useMarketCurrencies', () => {
 			    "imageUrl": "https://example.com/usdc.png",
 			    "name": "USD Coin",
 			    "nativeCurrency": false,
+			    "openseaListing": true,
+			    "openseaOffer": true,
 			    "status": "active",
 			    "symbol": "USDC",
 			    "updatedAt": "2025-03-16T13:04:16.098Z",

package/src/react/hooks/data/primary-sales/index.ts

@@ -4,3 +4,4 @@ export * from './useGetCountOfPrimarySaleItems';
 export * from './useList721ShopCardData';
 export * from './useList1155ShopCardData';
 export * from './useListPrimarySaleItems';
+export * from './usePrimarySaleItem';

package/src/react/hooks/data/primary-sales/usePrimarySaleItem.tsx

@@ -0,0 +1,71 @@
+'use client';
+
+import { useQuery } from '@tanstack/react-query';
+import type { Optional } from '../../../_internal';
+import {
+	type FetchPrimarySaleItemParams,
+	type PrimarySaleItemQueryOptions,
+	primarySaleItemQueryOptions,
+} from '../../../queries/primary-sales/primarySaleItem';
+import { useConfig } from '../../config/useConfig';
+
+export type UsePrimarySaleItemParams = Optional<
+	PrimarySaleItemQueryOptions,
+	'config'
+>;
+
+/**
+ * Hook to fetch a single primary sale item
+ *
+ * Retrieves details for a specific primary sale item from a primary sale contract.
+ *
+ * @param params - Configuration parameters
+ * @param params.chainId - The chain ID (must be number, e.g., 1 for Ethereum, 137 for Polygon)
+ * @param params.primarySaleContractAddress - The primary sale contract address
+ * @param params.tokenId - The token ID of the primary sale item
+ * @param params.query - Optional React Query configuration
+ *
+ * @returns Query result containing the primary sale item data
+ *
+ * @example
+ * Basic usage:
+ * ```typescript
+ * const { data: item, isLoading } = usePrimarySaleItem({
+ *   chainId: 137,
+ *   primarySaleContractAddress: '0x...',
+ *   tokenId: '1',
+ * })
+ * ```
+ *
+ * @example
+ * With custom query options:
+ * ```typescript
+ * const { data } = usePrimarySaleItem({
+ *   chainId: 1,
+ *   primarySaleContractAddress: '0x...',
+ *   tokenId: '42',
+ *   query: {
+ *     enabled: Boolean(primarySaleContractAddress && tokenId),
+ *     staleTime: 30_000
+ *   }
+ * })
+ * ```
+ */
+export function usePrimarySaleItem(params: UsePrimarySaleItemParams) {
+	const defaultConfig = useConfig();
+
+	const { config = defaultConfig, ...rest } = params;
+
+	const queryOptions = primarySaleItemQueryOptions({
+		config,
+		...rest,
+	});
+
+	return useQuery({
+		...queryOptions,
+	});
+}
+
+export { primarySaleItemQueryOptions };
+
+export type { FetchPrimarySaleItemParams, PrimarySaleItemQueryOptions };

package/src/react/hooks/data/tokens/useListBalances.tsx

@@ -1,9 +1,7 @@
 import { useInfiniteQuery } from '@tanstack/react-query';
-import { ContractType } from '../../../_internal';
 import type { UseListBalancesArgs } from '../../../queries/tokens/listBalances';
 import { listBalancesOptions } from '../../../queries/tokens/listBalances';
 import { useConfig } from '../../config/useConfig';
-import { useMarketplaceConfig } from '../../config/useMarketplaceConfig';
 
 /**
  * Hook to fetch a list of token balances with pagination support
@@ -26,13 +24,6 @@ import { useMarketplaceConfig } from '../../config/useMarketplaceConfig';
  */
 export function useListBalances(args: UseListBalancesArgs) {
 	const config = useConfig();
-	const { data: marketplaceConfig } = useMarketplaceConfig();
 
-	const isLaos721 =
-		marketplaceConfig?.market?.collections?.find(
-			(c) =>
-				c.itemsAddress === args.contractAddress && c.chainId === args.chainId,
-		)?.contractType === ContractType.LAOS_ERC_721;
-
-	return useInfiniteQuery(listBalancesOptions({ ...args, isLaos721 }, config));
+	return useInfiniteQuery(listBalancesOptions({ ...args }, config));
 }

package/src/react/hooks/data/tokens/useTokenSupplies.ts

@@ -15,15 +15,13 @@ export type UseTokenSuppliesParams = Optional<
 >;
 
 /**
- * Hook to fetch token supplies from the indexer or LAOS API
+ * Hook to fetch token supplies from the indexer
  *
  * Retrieves supply information for tokens from a specific collection.
- * Automatically chooses between indexer and LAOS APIs based on the isLaos721 flag.
  *
  * @param params - Configuration parameters
  * @param params.chainId - The chain ID (must be number, e.g., 1 for Ethereum, 137 for Polygon)
  * @param params.collectionAddress - The collection contract address
- * @param params.isLaos721 - Whether to use LAOS API instead of indexer
  * @param params.includeMetadata - Whether to include token metadata
  * @param params.page - Pagination options
  * @param params.query - Optional React Query configuration
@@ -40,16 +38,6 @@ export type UseTokenSuppliesParams = Optional<
  * ```
  *
  * @example
- * With LAOS API:
- * ```typescript
- * const { data, isLoading } = useTokenSupplies({
- *   chainId: 1,
- *   collectionAddress: '0x...',
- *   isLaos721: true
- * })
- * ```
- *
- * @example
  * With conditional fetching:
  * ```typescript
  * const { data, isLoading } = useTokenSupplies({

package/src/react/hooks/transactions/useGenerateOfferTransaction.test.tsx

@@ -9,6 +9,7 @@ import {
 } from '../../_internal/api/__mocks__/marketplace.msw';
 import {
 	ContractType,
+	OfferType,
 	OrderbookKind,
 	StepType,
 } from '../../_internal/api/marketplace.gen';
@@ -33,6 +34,7 @@ describe('useGenerateOfferTransaction', () => {
 		orderbook: OrderbookKind.sequence_marketplace_v2,
 		offer: mockOffer,
 		additionalFees: [],
+		offerType: OfferType.item,
 	};
 
 	const defaultArgs = {