@0xsequence/marketplace-sdk 1.1.1 → 1.2.0

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 = {

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

@@ -158,12 +158,14 @@ describe('useProcessStep', () => {
 				message: 'Sign this message',
 			});
 			expect(mockExecute).toHaveBeenCalledWith({
-				chainId: '1',
-				signature: mockSignature,
-				method: 'POST',
-				endpoint: '/api/order',
-				body: { test: 'data' },
-				executeType: ExecuteType.order,
+				params: {
+					chainId: '1',
+					signature: mockSignature,
+					method: 'POST',
+					endpoint: '/api/order',
+					body: { test: 'data' },
+					executeType: ExecuteType.order,
+				},
 			});
 		});
 

package/src/react/hooks/transactions/useProcessStep.ts

@@ -73,12 +73,14 @@ export const useProcessStep = () => {
 			// Call execute endpoint with signature
 			if (step.post) {
 				const result = await marketplaceClient.execute({
-					chainId: String(chainId),
-					signature,
-					method: step.post.method,
-					endpoint: step.post.endpoint,
-					body: step.post.body,
-					executeType: ExecuteType.order,
+					params: {
+						chainId: String(chainId),
+						signature,
+						method: step.post.method,
+						endpoint: step.post.endpoint,
+						body: step.post.body,
+						executeType: ExecuteType.order,
+					},
 				});
 
 				return { type: 'signature', orderId: result.orderId };

package/src/react/hooks/utils/useComparePrices.test.tsx

@@ -61,7 +61,7 @@ describe('useComparePrices', () => {
 		// 1 ETH vs 1 USDC = 2000 vs 1 = 199900% difference
 		expect(result.current.data).toEqual({
 			percentageDifference: 199900,
-			percentageDifferenceFormatted: '199900.00',
+			percentageDifferenceFormatted: '199,900.00',
 			status: 'above',
 		});
 	});

package/src/react/providers/modal-provider.tsx

@@ -22,7 +22,8 @@ export const ModalProvider = observer(({ children }: ModalProviderProps) => {
 	const { shadowDom, experimentalShadowDomCssOverride } = sdkConfig;
 
 	const overrides = sdkConfig._internal?.overrides?.api?.marketplace;
-	const marketplaceApiUrl = overrides?.url || marketplaceApiURL(overrides?.env || 'production');
+	const marketplaceApiUrl =
+		overrides?.url || marketplaceApiURL(overrides?.env || 'production');
 
 	return (
 		<>

package/src/react/queries/collectibles/balanceOfCollectible.ts

@@ -2,14 +2,13 @@ import { queryOptions, skipToken } from '@tanstack/react-query';
 import type { Address } from 'viem';
 import type { UseQueryParameters } from 'wagmi/query';
 import type { SdkConfig } from '../../../types';
-import { collectableKeys, getIndexerClient, LaosAPI } from '../../_internal';
+import { collectableKeys, getIndexerClient } from '../../_internal';
 
 export type UseBalanceOfCollectibleArgs = {
 	collectionAddress: Address;
 	collectableId: string;
 	userAddress: Address | undefined;
 	chainId: number;
-	isLaos721?: boolean;
 	includeMetadata?: boolean;
 	query?: UseQueryParameters;
 };
@@ -27,18 +26,6 @@ export async function fetchBalanceOfCollectible(
 	},
 	config: SdkConfig,
 ) {
-	if (args.isLaos721) {
-		const laosApi = new LaosAPI();
-		const response = await laosApi.getTokenBalances({
-			chainId: args.chainId.toString(),
-			contractAddress: args.collectionAddress,
-			accountAddress: args.userAddress,
-			includeMetadata: true,
-		});
-
-		return response.balances[0] || null;
-	}
-
 	const indexerClient = getIndexerClient(args.chainId, config);
 	return indexerClient
 		.getTokenBalances({
@@ -69,7 +56,6 @@ export function getBalanceOfCollectibleQueryKey(
 					includeContracts: [args.collectionAddress],
 				}
 			: undefined,
-		isLaos721: args.isLaos721,
 	};
 
 	return [...collectableKeys.userBalances, apiArgs] as const;

package/src/react/queries/collectibles/listCollectibles.ts

@@ -9,25 +9,14 @@ import type {
 	QueryKeyArgs,
 	ValuesOptional,
 } from '../../_internal';
-import {
-	type CollectibleOrder,
-	collectableKeys,
-	getMarketplaceClient,
-	MetadataStatus,
-	OrderSide,
-} from '../../_internal';
+import { collectableKeys, getMarketplaceClient } from '../../_internal';
 import type { StandardInfiniteQueryOptions } from '../../types/query';
 import { fetchMarketplaceConfig } from '../market/marketplaceConfig';
-import {
-	fetchBalances,
-	type UseListBalancesArgs,
-} from '../tokens/listBalances';
 
 export interface FetchListCollectiblesParams
 	extends Omit<ListCollectiblesArgs, 'chainId' | 'contractAddress'> {
 	chainId: number;
 	collectionAddress: Address;
-	isLaos721?: boolean;
 	cardType?: CardType;
 	config: SdkConfig;
 	enabled?: boolean;
@@ -66,47 +55,6 @@ export async function fetchListCollectibles(
 		...additionalApiParams,
 	};
 
-	if (params.isLaos721 && params.side === OrderSide.listing) {
-		try {
-			const fetchBalancesArgs = {
-				chainId: params.chainId,
-				accountAddress: params.filter?.inAccounts?.[0] as Address,
-				contractAddress: params.collectionAddress,
-				page: page,
-				includeMetadata: true,
-				isLaos721: true,
-			} satisfies UseListBalancesArgs;
-
-			const balances = await fetchBalances(fetchBalancesArgs, config, page);
-			const collectibles: CollectibleOrder[] = balances.balances.map(
-				(balance) => {
-					if (!balance.tokenMetadata)
-						throw new Error('Token metadata not found');
-					return {
-						metadata: {
-							tokenId: balance.tokenID ?? '',
-							attributes: balance.tokenMetadata.attributes,
-							image: balance.tokenMetadata.image,
-							name: balance.tokenMetadata.name,
-							description: balance.tokenMetadata.description,
-							video: balance.tokenMetadata.video,
-							audio: balance.tokenMetadata.audio,
-							status: MetadataStatus.AVAILABLE,
-						},
-					};
-				},
-			);
-			return {
-				collectibles: collectibles,
-				//@ts-expect-error
-				page: balances.page,
-			};
-		} catch (error) {
-			// If the request fails, ignore the error and return the collectibles from our indexer
-			console.error(error);
-		}
-	}
-
 	return await marketplaceClient.listCollectibles(apiArgs);
 }
 
@@ -153,7 +101,6 @@ export function listCollectiblesQueryOptions(
 					// biome-ignore lint/style/noNonNullAssertion: The enabled check above ensures these are not undefined
 					side: params.side!,
 					filter: params.filter,
-					isLaos721: params.isLaos721,
 					cardType: params.cardType,
 				},
 				pageParam,