@0xsequence/marketplace-sdk 1.0.0 → 1.1.1

package/src/react/hooks/data/orders/useListOffersForCollectible.tsx

@@ -1,55 +1,80 @@
-import { queryOptions, useQuery } from '@tanstack/react-query';
-import type { SdkConfig } from '../../../../types';
+'use client';
+
+import { useQuery } from '@tanstack/react-query';
+import type { Optional } from '../../../_internal';
 import {
-	collectableKeys,
-	getMarketplaceClient,
-	type ListOffersForCollectibleArgs,
-} from '../../../_internal';
-import type { OrderFilter, Page } from '../../../_internal/api/marketplace.gen';
+	type FetchListOffersForCollectibleParams,
+	type ListOffersForCollectibleQueryOptions,
+	listOffersForCollectibleQueryOptions,
+} from '../../../queries/orders/listOffersForCollectible';
 import { useConfig } from '../../config/useConfig';
 
-interface UseListOffersForCollectibleArgs {
-	chainId: number;
-	collectionAddress: string;
-	collectibleId: string;
-	filter?: OrderFilter;
-	page?: Page;
-}
-
-export type UseListOffersForCollectibleReturn = Awaited<
-	ReturnType<typeof fetchListOffersForCollectible>
+export type UseListOffersForCollectibleParams = Optional<
+	ListOffersForCollectibleQueryOptions,
+	'config'
 >;
 
-const fetchListOffersForCollectible = async (
-	config: SdkConfig,
-	args: UseListOffersForCollectibleArgs,
-) => {
-	const arg = {
-		chainId: String(args.chainId),
-		contractAddress: args.collectionAddress,
-		tokenId: args.collectibleId,
-		filter: args.filter,
-		page: args.page,
-	} satisfies ListOffersForCollectibleArgs;
-
-	const marketplaceClient = getMarketplaceClient(config);
-	return marketplaceClient.listCollectibleOffers(arg);
-};
+/**
+ * Hook to fetch offers for a specific collectible
+ *
+ * Fetches offers for a specific collectible 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.collectibleId - The specific collectible ID to fetch offers for
+ * @param params.filter - Optional filtering parameters
+ * @param params.page - Optional pagination parameters
+ * @param params.query - Optional React Query configuration
+ *
+ * @returns Query result containing offers data
+ *
+ * @example
+ * Basic usage:
+ * ```typescript
+ * const { data, isLoading } = useListOffersForCollectible({
+ *   chainId: 137,
+ *   collectionAddress: '0x...',
+ *   collectibleId: '1'
+ * })
+ * ```
+ *
+ * @example
+ * With filtering:
+ * ```typescript
+ * const { data } = useListOffersForCollectible({
+ *   chainId: 1,
+ *   collectionAddress: '0x...',
+ *   collectibleId: '1',
+ *   filter: {
+ *     marketplace: [MarketplaceKind.sequence_marketplace_v2]
+ *   }
+ * })
+ * ```
+ */
+export function useListOffersForCollectible(
+	params: UseListOffersForCollectibleParams,
+) {
+	const defaultConfig = useConfig();
+
+	const { config = defaultConfig, ...rest } = params;
 
-export const listOffersForCollectibleOptions = (
-	args: UseListOffersForCollectibleArgs,
-	config: SdkConfig,
-) => {
-	return queryOptions({
-		queryKey: [...collectableKeys.offers, args, config],
-		queryFn: () => fetchListOffersForCollectible(config, args),
+	const queryOptions = listOffersForCollectibleQueryOptions({
+		config,
+		...rest,
 	});
-};
 
-export const useListOffersForCollectible = (
-	args: UseListOffersForCollectibleArgs,
-) => {
-	const config = useConfig();
+	return useQuery({
+		...queryOptions,
+	});
+}
 
-	return useQuery(listOffersForCollectibleOptions(args, config));
+export { listOffersForCollectibleQueryOptions };
+
+export type {
+	FetchListOffersForCollectibleParams,
+	ListOffersForCollectibleQueryOptions,
 };
+
+// Legacy export for backward compatibility during migration
+export type UseListOffersForCollectibleArgs = UseListOffersForCollectibleParams;

package/src/react/hooks/data/orders/useLowestListing.tsx

@@ -6,7 +6,7 @@ import {
 	type FetchLowestListingParams,
 	type LowestListingQueryOptions,
 	lowestListingQueryOptions,
-} from '../../../queries/lowestListing';
+} from '../../../queries/orders/lowestListing';
 import { useConfig } from '../../config/useConfig';
 
 export type UseLowestListingParams = Optional<

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

@@ -2,8 +2,8 @@
 
 import { useQuery } from '@tanstack/react-query';
 import type { Optional } from '../../../_internal';
-import type { ListPrimarySaleItemsQueryOptions } from '../../../queries/primarySaleItems';
-import { primarySaleItemsCountQueryOptions } from '../../../queries/primarySaleItemsCount';
+import type { ListPrimarySaleItemsQueryOptions } from '../../../queries/primary-sales/primarySaleItems';
+import { primarySaleItemsCountQueryOptions } from '../../../queries/primary-sales/primarySaleItemsCount';
 import { useConfig } from '../../config/useConfig';
 
 export type UseGetCountParams = Optional<

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

@@ -1,14 +1,19 @@
 import type { Address } from 'viem';
 import { useReadContract } from 'wagmi';
-import { ContractType, type TokenMetadata } from '../../../_internal';
+import {
+	ContractType,
+	type PrimarySaleItem,
+	type TokenMetadata,
+} from '../../../_internal';
 import type { ShopCollectibleCardProps } from '../../../ui/components/marketplace-collectible-card/types';
 import { useSalesContractABI } from '../../contracts/useSalesContractABI';
-import { useFilterState } from '../../ui/useFilterState';
 import { useCollection } from '../collections/useCollection';
-import { useListPrimarySaleItems } from '../primary-sales/useListPrimarySaleItems';
 
 interface UseList1155ShopCardDataProps {
-	tokenIds: string[];
+	primarySaleItemsWithMetadata: Array<{
+		metadata: TokenMetadata;
+		primarySaleItem: PrimarySaleItem;
+	}>;
 	chainId: number;
 	contractAddress: Address;
 	salesContractAddress: Address;
@@ -16,13 +21,12 @@ interface UseList1155ShopCardDataProps {
 }
 
 export function useList1155ShopCardData({
-	tokenIds,
+	primarySaleItemsWithMetadata,
 	chainId,
 	contractAddress,
 	salesContractAddress,
 	enabled = true,
 }: UseList1155ShopCardDataProps) {
-	const { showListedOnly } = useFilterState();
 	const { abi, isLoading: versionLoading } = useSalesContractABI({
 		contractAddress: salesContractAddress,
 		contractType: ContractType.ERC1155,
@@ -30,21 +34,12 @@ export function useList1155ShopCardData({
 		enabled,
 	});
 
-	const {
-		data: primarySaleItems,
-		isLoading: primarySaleItemsLoading,
-		error: primarySaleItemsError,
-	} = useListPrimarySaleItems({
-		chainId,
-		primarySaleContractAddress: salesContractAddress,
-		filter: {
-			includeEmpty: !showListedOnly,
-		},
-	});
-
 	const { data: collection, isLoading: collectionLoading } = useCollection({
 		chainId,
 		collectionAddress: contractAddress,
+		query: {
+			enabled,
+		},
 	});
 
 	const { data: paymentToken, isLoading: paymentTokenLoading } =
@@ -58,21 +53,10 @@ export function useList1155ShopCardData({
 			},
 		});
 
-	const isLoading =
-		primarySaleItemsLoading || collectionLoading || paymentTokenLoading;
-
-	// Flatten all collectibles from all pages
-	const allPrimarySaleItems =
-		primarySaleItems?.pages.flatMap((page) => page.primarySaleItems) ?? [];
-
-	const collectibleCards = tokenIds.map((tokenId) => {
-		const matchingPrimarySaleItem = allPrimarySaleItems.find(
-			(item) => item.primarySaleItem.tokenId?.toString() === tokenId,
-		);
+	const isLoading = versionLoading || collectionLoading || paymentTokenLoading;
 
-		const saleData = matchingPrimarySaleItem?.primarySaleItem;
-		const tokenMetadata =
-			matchingPrimarySaleItem?.metadata || ({} as TokenMetadata);
+	const collectibleCards = primarySaleItemsWithMetadata.map((item) => {
+		const { metadata, primarySaleItem: saleData } = item;
 
 		const salePrice = {
 			amount: saleData?.priceAmount?.toString() || '',
@@ -85,11 +69,11 @@ export function useList1155ShopCardData({
 		const unlimitedSupply = saleData?.unlimitedSupply;
 
 		return {
-			collectibleId: tokenId,
+			collectibleId: metadata.tokenId,
 			chainId,
 			collectionAddress: contractAddress,
 			collectionType: ContractType.ERC1155,
-			tokenMetadata: tokenMetadata,
+			tokenMetadata: metadata,
 			cardLoading: isLoading,
 			salesContractAddress: salesContractAddress,
 			salePrice,
@@ -99,14 +83,14 @@ export function useList1155ShopCardData({
 			unlimitedSupply,
 			saleStartsAt: saleData?.startDate?.toString(),
 			saleEndsAt: saleData?.endDate?.toString(),
-			marketplaceType: 'shop',
+			cardType: 'shop',
 		} satisfies ShopCollectibleCardProps;
 	});
 
 	return {
 		collectibleCards,
-		tokenMetadataError: primarySaleItemsError,
+		tokenMetadataError: null,
 		tokenSaleDetailsError: null,
-		isLoading,
+		isLoading: enabled && isLoading,
 	};
 }

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

@@ -37,12 +37,19 @@ export function useList721ShopCardData({
 	});
 	const config = useConfig();
 
+	const tokenSuppliesEnabled = Boolean(
+		chainId && contractAddress && config && (enabled ?? true),
+	);
+	// TODO: Find a way to remove this and use enabled in tokenSuppliesQueryOptions
 	const tokenSuppliesQuery = useInfiniteQuery({
 		...tokenSuppliesQueryOptions({
 			chainId,
 			collectionAddress: contractAddress,
 			includeMetadata: true,
 			config,
+			query: {
+				enabled: tokenSuppliesEnabled,
+			},
 		}),
 	});
 
@@ -56,6 +63,8 @@ export function useList721ShopCardData({
 
 	useEffect(() => {
 		async function fetchAllPages() {
+			if (!tokenSuppliesEnabled) return;
+
 			if (!hasNextSuppliesPage && tokenSuppliesData) {
 				setAllTokenSuppliesFetched(true);
 				return;
@@ -72,6 +81,7 @@ export function useList721ShopCardData({
 		isFetchingNextSuppliesPage,
 		tokenSuppliesLoading,
 		fetchNextTokenSuppliesPage,
+		tokenSuppliesEnabled,
 	]);
 
 	const allTokenSupplies = tokenSuppliesData?.pages.flatMap(
@@ -137,7 +147,7 @@ export function useList721ShopCardData({
 				quantityDecimals: 0,
 				saleStartsAt,
 				saleEndsAt,
-				marketplaceType: 'shop',
+				cardType: 'shop',
 			} satisfies ShopCollectibleCardProps;
 		},
 	);
@@ -160,7 +170,7 @@ export function useList721ShopCardData({
 			quantityDecimals: 0,
 			saleStartsAt: undefined,
 			saleEndsAt: undefined,
-			marketplaceType: 'shop',
+			cardType: 'shop',
 		} satisfies ShopCollectibleCardProps;
 	});
 
@@ -177,7 +187,8 @@ export function useList721ShopCardData({
 		saleDetailsError,
 		saleDetails,
 		isLoading:
-			saleDetailsLoading || tokenSuppliesLoading || !allTokenSuppliesFetched,
+			enabled &&
+			(saleDetailsLoading || tokenSuppliesLoading || !allTokenSuppliesFetched),
 		tokenSuppliesData,
 	};
 }

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

@@ -5,7 +5,7 @@ import type { Optional } from '../../../_internal';
 import {
 	type ListPrimarySaleItemsQueryOptions,
 	listPrimarySaleItemsQueryOptions,
-} from '../../../queries/primarySaleItems';
+} from '../../../queries/primary-sales/primarySaleItems';
 import { useConfig } from '../../config/useConfig';
 
 export type UseListPrimarySaleItemsParams = Optional<

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

@@ -7,7 +7,7 @@ import {
 	type FetchGetTokenRangesParams,
 	type GetTokenRangesQueryOptions,
 	getTokenRangesQueryOptions,
-} from '../../../queries/getTokenRanges';
+} from '../../../queries/tokens/getTokenRanges';
 import { useConfig } from '../../config/useConfig';
 
 export type UseGetTokenRangesParams = Optional<
@@ -89,6 +89,6 @@ export type UseGetTokenRangesProps = {
 
 export type UseGetTokenRangesReturn = Awaited<
 	ReturnType<
-		typeof import('../../../queries/getTokenRanges').fetchGetTokenRanges
+		typeof import('../../../queries/tokens/getTokenRanges').fetchGetTokenRanges
 	>
 >;

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

@@ -1,7 +1,7 @@
 import { useInfiniteQuery } from '@tanstack/react-query';
 import { ContractType } from '../../../_internal';
-import type { UseListBalancesArgs } from '../../../queries/listBalances';
-import { listBalancesOptions } from '../../../queries/listBalances';
+import type { UseListBalancesArgs } from '../../../queries/tokens/listBalances';
+import { listBalancesOptions } from '../../../queries/tokens/listBalances';
 import { useConfig } from '../../config/useConfig';
 import { useMarketplaceConfig } from '../../config/useMarketplaceConfig';
 

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

@@ -6,7 +6,7 @@ import {
 	type FetchListTokenMetadataParams,
 	type ListTokenMetadataQueryOptions,
 	listTokenMetadataQueryOptions,
-} from '../../../queries/listTokenMetadata';
+} from '../../../queries/tokens/listTokenMetadata';
 import { useConfig } from '../../config/useConfig';
 
 export type UseListTokenMetadataParams = Optional<

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

@@ -5,7 +5,7 @@ import type { Optional } from '../../../_internal';
 import {
 	type SearchTokenMetadataQueryOptions,
 	searchTokenMetadataQueryOptions,
-} from '../../../queries/searchTokenMetadata';
+} from '../../../queries/tokens/searchTokenMetadata';
 import { useConfig } from '../../config/useConfig';
 import { useTokenSupplies } from './useTokenSupplies';
 
@@ -104,7 +104,10 @@ export function useSearchTokenMetadata(params: UseSearchTokenMetadataParams) {
 		collectionAddress: params.collectionAddress,
 		includeMetadata: true,
 		query: {
-			enabled: onlyMinted && (params.query?.enabled ?? true),
+			enabled:
+				onlyMinted &&
+				!!params.collectionAddress &&
+				(params.query?.enabled ?? true),
 		},
 	});
 

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

@@ -6,7 +6,7 @@ import {
 	type FetchTokenSuppliesParams,
 	type TokenSuppliesQueryOptions,
 	tokenSuppliesQueryOptions,
-} from '../../../queries/tokenSupplies';
+} from '../../../queries/tokens/tokenSupplies';
 import { useConfig } from '../../config/useConfig';
 
 export type UseTokenSuppliesParams = Optional<

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

@@ -1,12 +1,11 @@
 import { renderHook, server, waitFor } from '@test';
 import { HttpResponse, http } from 'msw';
+import type { Address } from 'viem';
 import { beforeEach, describe, expect, it, vi } from 'vitest';
-
 import * as types from '../../../types';
 import { StepType } from '../../../types';
 import { WalletKind } from '../../_internal/api';
 import { mockMarketplaceEndpoint } from '../../_internal/api/__mocks__/marketplace.msw';
-
 import { useConnectorMetadata } from '../config/useConnectorMetadata';
 import { useCancelOrder } from './useCancelOrder';
 import { useProcessStep } from './useProcessStep';
@@ -24,7 +23,7 @@ vi.mock('../../utils/waitForTransactionReceipt', () => ({
 
 describe('useCancelOrder', () => {
 	const defaultProps = {
-		collectionAddress: '0x1234567890123456789012345678901234567890',
+		collectionAddress: '0x1234567890123456789012345678901234567890' as Address,
 		chainId: 1,
 	};
 
@@ -99,7 +98,11 @@ describe('useCancelOrder', () => {
 	});
 
 	it('should update state during cancellation process', async () => {
-		const { result } = renderHook(() => useCancelOrder(defaultProps));
+		const { result } = renderHook(() =>
+			useCancelOrder({
+				...defaultProps,
+			}),
+		);
 
 		// Mock a delayed response
 		server.use(

package/src/react/hooks/transactions/useCancelOrder.tsx

@@ -1,12 +1,13 @@
 'use client';
 import { useWaasFeeOptions } from '@0xsequence/connect';
 import { useEffect, useState } from 'react';
+import type { Address } from 'viem';
 import type * as types from '../../_internal';
 import { useAutoSelectFeeOption } from '../utils/useAutoSelectFeeOption';
 import { useCancelTransactionSteps } from './useCancelTransactionSteps';
 
 interface UseCancelOrderArgs {
-	collectionAddress: string;
+	collectionAddress: Address;
 	chainId: number;
 	onSuccess?: ({ hash, orderId }: { hash?: string; orderId?: string }) => void;
 	onError?: (error: Error) => void;

package/src/react/hooks/transactions/useCancelTransactionSteps.tsx

@@ -1,4 +1,4 @@
-import type { Hex } from 'viem';
+import type { Address, Hex } from 'viem';
 import { useAccount } from 'wagmi';
 import { NoWalletConnectedError } from '../../../utils/_internal/error/transaction';
 import {
@@ -19,7 +19,7 @@ import { useGenerateCancelTransaction } from './useGenerateCancelTransaction';
 import { useProcessStep } from './useProcessStep';
 
 interface UseCancelTransactionStepsArgs {
-	collectionAddress: string;
+	collectionAddress: Address;
 	chainId: number;
 	callbacks?: ModalCallbacks;
 	setSteps: React.Dispatch<React.SetStateAction<TransactionStep>>;

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

@@ -126,6 +126,7 @@ describe('useGenerateCancelTransaction', () => {
 				createMockSteps([StepType.cancel]),
 				defaultArgs,
 				undefined,
+				expect.any(Object), // React Query context
 			);
 		});
 	});

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

@@ -31,6 +31,7 @@ describe('useGenerateListingTransaction', () => {
 		contractType: ContractType.ERC721,
 		orderbook: OrderbookKind.sequence_marketplace_v2,
 		listing: mockListing,
+		additionalFees: [],
 	};
 
 	const defaultArgs = {
@@ -64,6 +65,7 @@ describe('useGenerateListingTransaction', () => {
 			    },
 			  ],
 			  {
+			    "additionalFees": [],
 			    "collectionAddress": "0x0000000000000000000000000000000000000000",
 			    "contractType": "ERC721",
 			    "listing": {
@@ -77,6 +79,11 @@ describe('useGenerateListingTransaction', () => {
 			    "owner": "0x0000000000000000000000000000000000000000",
 			  },
 			  undefined,
+			  {
+			    "client": QueryClient {},
+			    "meta": undefined,
+			    "mutationKey": undefined,
+			  },
 			]
 		`);
 	});
@@ -111,6 +118,7 @@ describe('useGenerateListingTransaction', () => {
 			    },
 			  ],
 			  {
+			    "additionalFees": [],
 			    "collectionAddress": "0x0000000000000000000000000000000000000000",
 			    "contractType": "ERC721",
 			    "listing": {
@@ -124,6 +132,11 @@ describe('useGenerateListingTransaction', () => {
 			    "owner": "0x0000000000000000000000000000000000000000",
 			  },
 			  undefined,
+			  {
+			    "client": QueryClient {},
+			    "meta": undefined,
+			    "mutationKey": undefined,
+			  },
 			]
 		`);
 	});

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

@@ -32,6 +32,7 @@ describe('useGenerateOfferTransaction', () => {
 		contractType: ContractType.ERC721,
 		orderbook: OrderbookKind.sequence_marketplace_v2,
 		offer: mockOffer,
+		additionalFees: [],
 	};
 
 	const defaultArgs = {

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

@@ -77,6 +77,11 @@ describe('useGenerateSellTransaction', () => {
 			    "seller": "0x0000000000000000000000000000000000000000",
 			  },
 			  undefined,
+			  {
+			    "client": QueryClient {},
+			    "meta": undefined,
+			    "mutationKey": undefined,
+			  },
 			]
 		`);
 	});
@@ -93,6 +98,7 @@ describe('useGenerateSellTransaction', () => {
 				createMockSteps([StepType.tokenApproval, StepType.sell]),
 				mockTransactionProps,
 				undefined,
+				expect.any(Object), // React Query context
 			);
 		});
 	});

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

@@ -7,7 +7,7 @@ import { useProcessStep } from './useProcessStep';
 vi.mock('wagmi', async (importOriginal) => {
 	const actual = await importOriginal();
 	return {
-		// @ts-ignore - ignore spread type error
+		// @ts-expect-error - ignore spread type error
 		...actual,
 		useSendTransaction: vi.fn(),
 		useSignMessage: vi.fn(),
@@ -18,7 +18,7 @@ vi.mock('wagmi', async (importOriginal) => {
 vi.mock('../../_internal/api', async (importOriginal) => {
 	const actual = await importOriginal();
 	return {
-		// @ts-ignore - ignore spread type error
+		// @ts-expect-error - ignore spread type error
 		...actual,
 		getMarketplaceClient: vi.fn(() => ({
 			execute: vi.fn(),