@0xsequence/marketplace-sdk 1.2.0 → 2.0.0

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

@@ -1,18 +1,17 @@
-import { renderHook, server, waitFor } from '@test';
-
-import { HttpResponse, http } from 'msw';
-import { zeroAddress } from 'viem';
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-import {
-	createMockSteps,
-	mockMarketplaceEndpoint,
-} from '../../_internal/api/__mocks__/marketplace.msw';
 import {
 	ContractType,
 	OfferType,
 	OrderbookKind,
 	StepType,
-} from '../../_internal/api/marketplace.gen';
+} from '@0xsequence/api-client';
+import * as MarketplaceMocks from '@0xsequence/api-client/mocks/marketplace';
+
+const { createMockSteps, mockMarketplaceEndpoint } = MarketplaceMocks;
+
+import { renderHook, server, waitFor } from '@test';
+import { HttpResponse, http } from 'msw';
+import { zeroAddress } from 'viem';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
 
 import { useGenerateOfferTransaction } from './useGenerateOfferTransaction';
 
@@ -20,11 +19,11 @@ describe('useGenerateOfferTransaction', () => {
 	const mockOnSuccess = vi.fn();
 
 	const mockOffer = {
-		tokenId: '1',
-		quantity: '1',
+		tokenId: 1n,
+		quantity: 1n,
 		expiry: new Date('2024-12-31'),
 		currencyAddress: zeroAddress,
-		pricePerToken: '1000000000000000000',
+		pricePerToken: 1000000000000000000n,
 	};
 
 	const mockTransactionProps = {
@@ -33,8 +32,8 @@ describe('useGenerateOfferTransaction', () => {
 		contractType: ContractType.ERC721,
 		orderbook: OrderbookKind.sequence_marketplace_v2,
 		offer: mockOffer,
-		additionalFees: [],
 		offerType: OfferType.item,
+		additionalFees: [],
 	};
 
 	const defaultArgs = {
@@ -95,7 +94,7 @@ describe('useGenerateOfferTransaction', () => {
 	it('should handle invalid offer data', async () => {
 		const invalidOffer = {
 			...mockOffer,
-			pricePerToken: 'invalid-price',
+			pricePerToken: -1n,
 		};
 
 		server.use(

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

@@ -3,7 +3,7 @@ import type { SdkConfig } from '../../../types';
 import { dateToUnixTime } from '../../../utils/date';
 import {
 	type CreateReq,
-	type GenerateOfferTransactionArgs,
+	type GenerateOfferTransactionRequest,
 	getMarketplaceClient,
 	type Step,
 	type WalletKind,
@@ -11,7 +11,7 @@ import {
 import { useConfig } from '../config/useConfig';
 import { useConnectorMetadata } from '../config/useConnectorMetadata';
 
-export type UseGenerateOfferTransactionArgs = {
+export type UseGenerateOfferTransactionRequest = {
 	chainId: number;
 	onSuccess?: (data?: Step[]) => void;
 };
@@ -21,14 +21,14 @@ type CreateReqWithDateExpiry = Omit<CreateReq, 'expiry'> & {
 };
 
 export type GenerateOfferTransactionProps = Omit<
-	GenerateOfferTransactionArgs,
+	GenerateOfferTransactionRequest,
 	'offer'
 > & {
 	offer: CreateReqWithDateExpiry;
 };
 
-type GenerateOfferTransactionArgsWithNumberChainId = Omit<
-	GenerateOfferTransactionArgs,
+type GenerateOfferTransactionRequestWithNumberChainId = Omit<
+	GenerateOfferTransactionRequest,
 	'chainId' | 'offer'
 > & {
 	chainId: number;
@@ -36,22 +36,22 @@ type GenerateOfferTransactionArgsWithNumberChainId = Omit<
 };
 
 export const generateOfferTransaction = async (
-	params: GenerateOfferTransactionArgsWithNumberChainId,
+	params: GenerateOfferTransactionRequestWithNumberChainId,
 	config: SdkConfig,
 	walletKind?: WalletKind,
-) => {
+): Promise<Step[]> => {
 	const args = {
 		...params,
-		chainId: String(params.chainId),
+		chainId: params.chainId,
 		offer: { ...params.offer, expiry: dateToUnixTime(params.offer.expiry) },
 		walletType: walletKind,
-	} satisfies GenerateOfferTransactionArgs;
+	};
 	const marketplaceClient = getMarketplaceClient(config);
 	return (await marketplaceClient.generateOfferTransaction(args)).steps;
 };
 
 export const useGenerateOfferTransaction = (
-	params: UseGenerateOfferTransactionArgs,
+	params: UseGenerateOfferTransactionRequest,
 ) => {
 	const config = useConfig();
 	const { walletKind } = useConnectorMetadata();
@@ -59,7 +59,7 @@ export const useGenerateOfferTransaction = (
 	const { mutate, mutateAsync, ...result } = useMutation({
 		onSuccess: params.onSuccess,
 		mutationFn: (
-			args: Omit<GenerateOfferTransactionArgsWithNumberChainId, 'chainId'>,
+			args: Omit<GenerateOfferTransactionRequestWithNumberChainId, 'chainId'>,
 		) =>
 			generateOfferTransaction(
 				{ ...args, chainId: params.chainId },

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

@@ -1,13 +1,17 @@
-import { ContractType } from '@0xsequence/indexer';
+import { ContractType } from '@0xsequence/api-client';
+import * as MarketplaceMocks from '@0xsequence/api-client/mocks/marketplace';
+
+const { createMockSteps, mockMarketplaceEndpoint } = MarketplaceMocks;
+
+import {
+	MarketplaceKind,
+	OrderbookKind,
+	StepType,
+} from '@0xsequence/api-client';
 import { renderHook, server, waitFor } from '@test';
 import { HttpResponse, http } from 'msw';
 import { zeroAddress } from 'viem';
 import { beforeEach, describe, expect, it, vi } from 'vitest';
-import { MarketplaceKind, OrderbookKind, StepType } from '../../_internal';
-import {
-	createMockSteps,
-	mockMarketplaceEndpoint,
-} from '../../_internal/api/__mocks__/marketplace.msw';
 import { useGenerateSellTransaction } from './useGenerateSellTransaction';
 
 describe('useGenerateSellTransaction', () => {
@@ -15,7 +19,7 @@ describe('useGenerateSellTransaction', () => {
 
 	const mockOrderData = {
 		orderId: '1',
-		quantity: '1',
+		quantity: 1n,
 	};
 
 	const mockTransactionProps = {
@@ -26,6 +30,7 @@ describe('useGenerateSellTransaction', () => {
 		marketplace: MarketplaceKind.sequence_marketplace_v2,
 		ordersData: [mockOrderData],
 		additionalFees: [],
+		useWithTrails: false,
 	};
 
 	const defaultArgs = {
@@ -50,38 +55,18 @@ describe('useGenerateSellTransaction', () => {
 			    {
 			      "data": "0x...",
 			      "id": "tokenApproval",
-			      "price": "0",
+			      "price": 0n,
 			      "to": "0x1234567890123456789012345678901234567890",
-			      "value": "0",
+			      "value": 0n,
 			    },
 			    {
 			      "data": "0x...",
 			      "id": "sell",
-			      "price": "0",
+			      "price": 0n,
 			      "to": "0x1234567890123456789012345678901234567890",
-			      "value": "0",
+			      "value": 0n,
 			    },
 			  ],
-			  {
-			    "additionalFees": [],
-			    "collectionAddress": "0x0000000000000000000000000000000000000000",
-			    "contractType": "ERC721",
-			    "marketplace": "sequence_marketplace_v2",
-			    "orderbook": "sequence_marketplace_v2",
-			    "ordersData": [
-			      {
-			        "orderId": "1",
-			        "quantity": "1",
-			      },
-			    ],
-			    "seller": "0x0000000000000000000000000000000000000000",
-			  },
-			  undefined,
-			  {
-			    "client": QueryClient {},
-			    "meta": undefined,
-			    "mutationKey": undefined,
-			  },
 			]
 		`);
 	});
@@ -94,12 +79,17 @@ describe('useGenerateSellTransaction', () => {
 		result.current.generateSellTransaction(mockTransactionProps);
 
 		await waitFor(() => {
-			expect(mockOnSuccess).toHaveBeenCalledWith(
-				createMockSteps([StepType.tokenApproval, StepType.sell]),
-				mockTransactionProps,
-				undefined,
-				expect.any(Object), // React Query context
-			);
+			const expectedSteps = createMockSteps([
+				StepType.tokenApproval,
+				StepType.sell,
+			]).map(({ id, data, to, price, value }) => ({
+				id,
+				data,
+				to,
+				price,
+				value,
+			}));
+			expect(mockOnSuccess).toHaveBeenCalledWith(expectedSteps);
 		});
 	});
 
@@ -125,7 +115,7 @@ describe('useGenerateSellTransaction', () => {
 	it('should handle invalid sell data', async () => {
 		const invalidOrderData = {
 			orderId: '1',
-			quantity: 'invalid-quantity',
+			quantity: 'invalid-quantity' as any,
 		};
 
 		server.use(

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

@@ -1,45 +1,46 @@
+import type { Step } from '@0xsequence/api-client';
 import { useMutation } from '@tanstack/react-query';
 import type { SdkConfig } from '../../../types/index';
 import {
-	type GenerateSellTransactionArgs,
+	type GenerateSellTransactionRequest,
 	getMarketplaceClient,
 } from '../../_internal';
-import type { Step } from '../../_internal/api/marketplace.gen';
 import { useConfig } from '../config/useConfig';
 
-interface UseGenerateSellTransactionArgs {
+interface UseGenerateSellTransactionRequest {
 	chainId: number;
 	onSuccess?: (steps?: Step[]) => void;
 }
 
-type GenerateSellTransactionArgsWithNumberChainId = Omit<
-	GenerateSellTransactionArgs,
+type GenerateSellTransactionRequestWithNumberChainId = Omit<
+	GenerateSellTransactionRequest,
 	'chainId'
 > & { chainId: number };
 
 export const generateSellTransaction = async (
-	args: GenerateSellTransactionArgsWithNumberChainId,
+	args: GenerateSellTransactionRequestWithNumberChainId,
 	config: SdkConfig,
-) => {
+): Promise<Step[]> => {
 	const marketplaceClient = getMarketplaceClient(config);
-	const argsWithStringChainId = {
-		...args,
-		chainId: String(args.chainId),
-	} satisfies GenerateSellTransactionArgs;
 	return marketplaceClient
-		.generateSellTransaction(argsWithStringChainId)
+		.generateSellTransaction(args)
 		.then((data) => data.steps);
 };
 
 export const useGenerateSellTransaction = (
-	params: UseGenerateSellTransactionArgs,
+	params: UseGenerateSellTransactionRequest,
 ) => {
 	const config = useConfig();
 
 	const { mutate, mutateAsync, ...result } = useMutation({
-		onSuccess: params.onSuccess,
+		onSuccess: (data) => {
+			// Only pass the data (steps) to the user's onSuccess callback to maintain backwards compatibility
+			if (params.onSuccess) {
+				params.onSuccess(data);
+			}
+		},
 		mutationFn: (
-			args: Omit<GenerateSellTransactionArgsWithNumberChainId, 'chainId'>,
+			args: Omit<GenerateSellTransactionRequestWithNumberChainId, 'chainId'>,
 		) => generateSellTransaction({ ...args, chainId: params.chainId }, config),
 	});
 

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

@@ -0,0 +1,105 @@
+import { MarketplaceKind, StepType } from '@0xsequence/api-client';
+import * as MarketplaceMocks from '@0xsequence/api-client/mocks/marketplace';
+import { renderHook, server, waitFor } from '@test';
+import { HttpResponse, http } from 'msw';
+import { zeroAddress } from 'viem';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { useMarketTransactionSteps } from './useMarketTransactionSteps';
+
+const { mockMarketplaceEndpoint, createMockSteps } = MarketplaceMocks;
+
+describe('useMarketTransactionSteps', () => {
+	const mockParams = {
+		chainId: 1,
+		collectionAddress: zeroAddress,
+		buyer: zeroAddress,
+		marketplace: MarketplaceKind.sequence_marketplace_v2,
+		orderId: '1',
+		tokenId: 1n,
+		quantity: 1n,
+		additionalFees: [],
+	};
+
+	beforeEach(() => {
+		vi.clearAllMocks();
+	});
+
+	it('should generate steps successfully', async () => {
+		// Mock the API response
+		const mockSteps = createMockSteps([StepType.tokenApproval, StepType.buy]);
+		server.use(
+			http.post(mockMarketplaceEndpoint('GenerateBuyTransaction'), async () => {
+				return HttpResponse.json({
+					steps: mockSteps,
+					resp: { canBeUsedWithTrails: true },
+				});
+			}),
+		);
+
+		const { result } = renderHook(() => useMarketTransactionSteps(mockParams));
+
+		await waitFor(() => {
+			expect(result.current.isSuccess).toBe(true);
+		});
+
+		expect(result.current.data?.steps).toHaveLength(2);
+		expect(result.current.data?.canBeUsedWithTrails).toBe(true);
+	});
+
+	it('should verify checkoutMode configuration', async () => {
+		// We'll spy on the request to verify the payload
+		const requestSpy = vi.fn();
+
+		server.use(
+			http.post(
+				mockMarketplaceEndpoint('GenerateBuyTransaction'),
+				async ({ request }) => {
+					const body = await request.json();
+					requestSpy(body);
+					return HttpResponse.json({
+						steps: [],
+						resp: { canBeUsedWithTrails: true },
+					});
+				},
+			),
+		);
+
+		// Test default behavior (should be true for trails)
+		const { result, unmount } = renderHook(() =>
+			useMarketTransactionSteps(mockParams),
+		);
+
+		await waitFor(() => expect(result.current.isSuccess).toBe(true));
+
+		expect(requestSpy).toHaveBeenLastCalledWith(
+			expect.objectContaining({
+				useWithTrails: true,
+			}),
+		);
+
+		unmount();
+	});
+
+	it('should not run when disabled', async () => {
+		const { result } = renderHook(() =>
+			useMarketTransactionSteps({ ...mockParams, enabled: false }),
+		);
+
+		expect(result.current.isPending).toBe(true);
+		expect(result.current.fetchStatus).toBe('idle');
+	});
+
+	it('should handle API errors', async () => {
+		server.use(
+			http.post(mockMarketplaceEndpoint('GenerateBuyTransaction'), () => {
+				return new HttpResponse(null, { status: 500 });
+			}),
+		);
+
+		const { result } = renderHook(() => useMarketTransactionSteps(mockParams));
+
+		await waitFor(() => {
+			expect(result.current.isError).toBe(true);
+		});
+	});
+});

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

@@ -0,0 +1,89 @@
+import type { Address } from '@0xsequence/api-client';
+import {
+	type AdditionalFee,
+	type MarketplaceKind,
+	type Step,
+	WalletKind,
+} from '@0xsequence/api-client';
+import { useQuery } from '@tanstack/react-query';
+import { useMemo } from 'react';
+import { getMarketplaceClient } from '../../_internal/api';
+import { useConfig } from '../config';
+
+export interface UseMarketTransactionStepsParams {
+	chainId: number;
+	collectionAddress: Address;
+	buyer: Address;
+	marketplace: MarketplaceKind;
+	orderId: string;
+	tokenId: bigint;
+	quantity: bigint;
+	additionalFees?: AdditionalFee[];
+	enabled?: boolean;
+}
+
+/**
+ * Hook to generate transaction steps for market transactions (secondary sales)
+ * This directly calls the marketplace API without using generators
+ */
+export function useMarketTransactionSteps({
+	chainId,
+	collectionAddress,
+	buyer,
+	marketplace,
+	orderId,
+	tokenId,
+	quantity,
+	additionalFees = [],
+	enabled = true,
+}: UseMarketTransactionStepsParams) {
+	const config = useConfig();
+	const marketplaceClient = useMemo(
+		() => getMarketplaceClient(config),
+		[config],
+	);
+
+	// Default to true when checkoutMode is undefined or 'trails'
+	// Only false when explicitly set to 'crypto' or 'sequence-checkout'
+	const useWithTrails =
+		config.checkoutMode === 'trails' || config.checkoutMode === undefined;
+
+	return useQuery<{ steps: Step[]; canBeUsedWithTrails: boolean }, Error>({
+		queryKey: [
+			'market-transaction-steps',
+			{
+				chainId,
+				collectionAddress,
+				buyer,
+				orderId,
+				tokenId,
+				quantity,
+				useWithTrails,
+			},
+		],
+		queryFn: async () => {
+			const response = await marketplaceClient.generateBuyTransaction({
+				chainId,
+				collectionAddress,
+				buyer,
+				marketplace,
+				ordersData: [
+					{
+						orderId,
+						quantity,
+						tokenId,
+					},
+				],
+				additionalFees,
+				walletType: WalletKind.unknown,
+				useWithTrails,
+			});
+
+			return {
+				steps: response.steps,
+				canBeUsedWithTrails: response.resp?.canBeUsedWithTrails ?? false,
+			};
+		},
+		enabled: enabled && !!buyer,
+	});
+}

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

@@ -1,9 +1,13 @@
+import {
+	type SignatureStep,
+	type Step,
+	StepType,
+	type TransactionStep,
+} from '@0xsequence/api-client';
 import {
 	BaseError,
 	type Hex,
-	hexToBigInt,
 	isHex,
-	type TypedDataDomain,
 	UserRejectedRequestError as ViemUserRejectedRequestError,
 } from 'viem';
 import {
@@ -19,9 +23,7 @@ import {
 	TransactionSignatureError,
 	UserRejectedRequestError,
 } from '../../../utils/_internal/error/transaction';
-import { type Step, StepType } from '../../_internal/api';
 import { createLogger } from '../../_internal/logger';
-import type { SignatureStep, TransactionStep } from '../../_internal/utils';
 
 const useTransactionOperations = () => {
 	const { sendTransactionAsync } = useSendTransaction();
@@ -57,19 +59,19 @@ const useTransactionOperations = () => {
 				return await signMessageAsync({ message });
 			}
 			if (stepItem.id === StepType.signEIP712) {
+				if (!stepItem.signature) {
+					throw new Error('EIP-712 step missing signature data');
+				}
+
 				logger.debug('Signing with EIP-712', {
-					domain: stepItem.domain,
-					types: stepItem.signature?.types,
+					domain: stepItem.signature.domain,
+					types: stepItem.signature.types,
 				});
 				return await signTypedDataAsync({
-					// biome-ignore lint/style/noNonNullAssertion: signature is guaranteed to exist for EIP712 step type
-					domain: stepItem.signature!.domain as TypedDataDomain,
-					// biome-ignore lint/style/noNonNullAssertion: signature is guaranteed to exist for EIP712 step type
-					types: stepItem.signature!.types,
-					// biome-ignore lint/style/noNonNullAssertion: signature is guaranteed to exist for EIP712 step type
-					primaryType: stepItem.signature!.primaryType,
-					// biome-ignore lint/style/noNonNullAssertion: signature is guaranteed to exist for EIP712 step type
-					message: stepItem.signature!.value,
+					domain: stepItem.signature.domain,
+					types: stepItem.signature.types,
+					primaryType: stepItem.signature.primaryType,
+					message: stepItem.signature.value,
 				});
 			}
 		} catch (e) {
@@ -77,7 +79,7 @@ const useTransactionOperations = () => {
 			logger.error('Signature failed', error);
 
 			if (error.cause instanceof BaseError) {
-				const viemError = error.cause as BaseError;
+				const viemError = error.cause;
 				if (viemError instanceof ViemUserRejectedRequestError) {
 					throw new UserRejectedRequestError();
 				}
@@ -102,23 +104,14 @@ const useTransactionOperations = () => {
 				chainId,
 				to: stepItem.to,
 				data: stepItem.data,
-				value: hexToBigInt(stepItem.value || '0x0'),
-				...(stepItem.maxFeePerGas && {
-					maxFeePerGas: hexToBigInt(stepItem.maxFeePerGas),
-				}),
-				...(stepItem.maxPriorityFeePerGas && {
-					maxPriorityFeePerGas: hexToBigInt(stepItem.maxPriorityFeePerGas),
-				}),
-				...(stepItem.gas && {
-					gas: hexToBigInt(stepItem.gas),
-				}),
+				value: stepItem.value || 0n,
 			});
 		} catch (e) {
 			const error = e as TransactionExecutionError;
 			logger.error('Transaction failed', error);
 
 			if (error.cause instanceof BaseError) {
-				const viemError = error.cause as BaseError;
+				const viemError = error.cause;
 				if (viemError instanceof ViemUserRejectedRequestError) {
 					throw new UserRejectedRequestError();
 				}
@@ -159,10 +152,8 @@ export const useOrderSteps = () => {
 
 		switch (step.id) {
 			case StepType.signEIP191:
-				result = await signMessage(step as SignatureStep);
-				break;
 			case StepType.signEIP712:
-				result = await signMessage(step as SignatureStep);
+				result = await signMessage(step);
 				break;
 			case StepType.buy:
 			case StepType.sell:
@@ -170,14 +161,10 @@ export const useOrderSteps = () => {
 			case StepType.createListing:
 			case StepType.createOffer:
 			case StepType.cancel:
-				result = await sendTransaction(chainId, step as TransactionStep);
+				result = await sendTransaction(chainId, step);
 				break;
-			case StepType.unknown:
-				throw new Error('Unknown step type');
-			default: {
-				const _exhaustiveCheck: never = step.id;
-				console.error(_exhaustiveCheck);
-			}
+			default:
+				throw new Error(`Cannot execute step type: ${step.id}`);
 		}
 
 		return result;