@0xsequence/marketplace-sdk 0.9.0 → 1.0.0

package/src/react/hooks/{useGenerateListingTransaction.tsx → transactions/useGenerateListingTransaction.tsx}

@@ -1,19 +1,19 @@
 import { useMutation } from '@tanstack/react-query';
-import { useConfig } from './useConfig';
+import { useConfig } from '../config/useConfig';
 
 export type UseGenerateListingTransactionArgs = {
 	chainId: number;
 	onSuccess?: (data?: Step[]) => void;
 };
 
-import type { SdkConfig } from '../../types';
-import { dateToUnixTime } from '../../utils/date';
+import type * as types from '../../../types';
+import { dateToUnixTime } from '../../../utils/date';
 import {
 	type CreateReq,
 	type GenerateListingTransactionArgs,
 	getMarketplaceClient,
 	type Step,
-} from '../_internal';
+} from '../../_internal';
 
 export type CreateReqWithDateExpiry = Omit<CreateReq, 'expiry'> & {
 	expiry: Date;
@@ -36,7 +36,7 @@ type GenerateListingTransactionArgsWithNumberChainId = Omit<
 
 export const generateListingTransaction = async (
 	params: GenerateListingTransactionArgsWithNumberChainId,
-	config: SdkConfig,
+	config: types.SdkConfig,
 ) => {
 	const args = {
 		...params,

package/src/react/hooks/{__tests__ → transactions}/useGenerateOfferTransaction.test.tsx

@@ -1,5 +1,5 @@
 import { renderHook, server, waitFor } from '@test';
-import { createMockWallet } from '@test/mocks/wallet';
+
 import { HttpResponse, http } from 'msw';
 import { zeroAddress } from 'viem';
 import { beforeEach, describe, expect, it, vi } from 'vitest';
@@ -11,10 +11,9 @@ import {
 	ContractType,
 	OrderbookKind,
 	StepType,
-	WalletKind,
 } from '../../_internal/api/marketplace.gen';
-import * as walletModule from '../../_internal/wallet/useWallet';
-import { useGenerateOfferTransaction } from '../useGenerateOfferTransaction';
+
+import { useGenerateOfferTransaction } from './useGenerateOfferTransaction';
 
 describe('useGenerateOfferTransaction', () => {
 	const mockOnSuccess = vi.fn();
@@ -118,32 +117,13 @@ describe('useGenerateOfferTransaction', () => {
 
 	describe('wallet-specific behavior', () => {
 		// Create mock wallets for different types
-		const mockSequenceWallet = createMockWallet({
-			walletKind: WalletKind.sequence,
-		});
-
-		const mockNonSequenceWallet = createMockWallet({
-			walletKind: WalletKind.unknown,
-		});
 
 		it('should not include tokenApproval step for Sequence wallet', async () => {
-			// Mock useWallet to return a Sequence wallet
-			const useWalletSpy = vi.spyOn(walletModule, 'useWallet');
-			useWalletSpy.mockReturnValue({
-				wallet: mockSequenceWallet,
-				isLoading: false,
-				isError: false,
-			});
-
-			// Override the default handler to include walletKind in the response
+			// Override the default handler for Sequence wallet
 			server.use(
 				http.post(
 					mockMarketplaceEndpoint('GenerateOfferTransaction'),
-					async ({ request }) => {
-						// Add wallet type to the request payload
-						const reqBody = (await request.json()) as Record<string, unknown>;
-						reqBody.walletType = WalletKind.sequence;
-
+					async () => {
 						// For Sequence wallet - only return createOffer step
 						return HttpResponse.json({
 							steps: createMockSteps([StepType.createOffer]),
@@ -164,29 +144,14 @@ describe('useGenerateOfferTransaction', () => {
 			// Verify there is only one step: createOffer (no tokenApproval)
 			expect(steps).toHaveLength(1);
 			expect(steps[0].id).toBe('createOffer');
-
-			// Restore the original useWallet implementation
-			useWalletSpy.mockRestore();
 		});
 
 		it('should include tokenApproval step for non-Sequence wallet', async () => {
-			// Mock useWallet to return a non-Sequence wallet
-			const useWalletSpy = vi.spyOn(walletModule, 'useWallet');
-			useWalletSpy.mockReturnValue({
-				wallet: mockNonSequenceWallet,
-				isLoading: false,
-				isError: false,
-			});
-
-			// Override the default handler to include walletKind in the response
+			// Override the default handler for non-Sequence wallet
 			server.use(
 				http.post(
 					mockMarketplaceEndpoint('GenerateOfferTransaction'),
-					async ({ request }) => {
-						// Add wallet type to the request payload
-						const reqBody = (await request.json()) as Record<string, unknown>;
-						reqBody.walletType = WalletKind.unknown;
-
+					async () => {
 						// For non-Sequence wallet - return tokenApproval and createOffer steps
 						return HttpResponse.json({
 							steps: createMockSteps([
@@ -211,9 +176,6 @@ describe('useGenerateOfferTransaction', () => {
 			expect(steps).toHaveLength(2);
 			expect(steps[0].id).toBe('tokenApproval');
 			expect(steps[1].id).toBe('createOffer');
-
-			// Restore the original useWallet implementation
-			useWalletSpy.mockRestore();
 		});
 	});
 });

package/src/react/hooks/{useGenerateOfferTransaction.tsx → transactions/useGenerateOfferTransaction.tsx}

@@ -1,15 +1,15 @@
 import { useMutation } from '@tanstack/react-query';
-import type { SdkConfig } from '../../types';
-import { dateToUnixTime } from '../../utils/date';
+import type { SdkConfig } from '../../../types';
+import { dateToUnixTime } from '../../../utils/date';
 import {
 	type CreateReq,
 	type GenerateOfferTransactionArgs,
 	getMarketplaceClient,
 	type Step,
 	type WalletKind,
-} from '../_internal';
-import { useWallet } from '../_internal/wallet/useWallet';
-import { useConfig } from './useConfig';
+} from '../../_internal';
+import { useConfig } from '../config/useConfig';
+import { useConnectorMetadata } from '../config/useConnectorMetadata';
 
 export type UseGenerateOfferTransactionArgs = {
 	chainId: number;
@@ -54,7 +54,7 @@ export const useGenerateOfferTransaction = (
 	params: UseGenerateOfferTransactionArgs,
 ) => {
 	const config = useConfig();
-	const { wallet } = useWallet();
+	const { walletKind } = useConnectorMetadata();
 
 	const { mutate, mutateAsync, ...result } = useMutation({
 		onSuccess: params.onSuccess,
@@ -64,7 +64,7 @@ export const useGenerateOfferTransaction = (
 			generateOfferTransaction(
 				{ ...args, chainId: params.chainId },
 				config,
-				wallet?.walletKind,
+				walletKind,
 			),
 	});
 

package/src/react/hooks/{__tests__ → transactions}/useGenerateSellTransaction.test.tsx

@@ -1,18 +1,14 @@
+import { ContractType } from '@0xsequence/indexer';
 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 {
-	ContractType,
-	MarketplaceKind,
-	OrderbookKind,
-	StepType,
-} from '../../_internal/api/marketplace.gen';
-import { useGenerateSellTransaction } from '../useGenerateSellTransaction';
+import { useGenerateSellTransaction } from './useGenerateSellTransaction';
 
 describe('useGenerateSellTransaction', () => {
 	const mockOnSuccess = vi.fn();

package/src/react/hooks/{useGenerateSellTransaction.tsx → transactions/useGenerateSellTransaction.tsx}

@@ -1,11 +1,11 @@
 import { useMutation } from '@tanstack/react-query';
-import type { SdkConfig } from '../../types';
+import type { SdkConfig } from '../../../types/index';
 import {
 	type GenerateSellTransactionArgs,
 	getMarketplaceClient,
-} from '../_internal';
-import type { Step } from '../_internal/api/marketplace.gen';
-import { useConfig } from './useConfig';
+} from '../../_internal';
+import type { Step } from '../../_internal/api/marketplace.gen';
+import { useConfig } from '../config/useConfig';
 
 interface UseGenerateSellTransactionArgs {
 	chainId: number;

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

@@ -0,0 +1,189 @@
+import {
+	BaseError,
+	type Hex,
+	hexToBigInt,
+	isHex,
+	type TypedDataDomain,
+	UserRejectedRequestError as ViemUserRejectedRequestError,
+} from 'viem';
+import {
+	useChainId,
+	useSendTransaction,
+	useSignMessage,
+	useSignTypedData,
+	useSwitchChain,
+} from 'wagmi';
+import {
+	ChainSwitchError,
+	TransactionExecutionError,
+	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();
+	const { signMessageAsync } = useSignMessage();
+	const { signTypedDataAsync } = useSignTypedData();
+	const { switchChainAsync } = useSwitchChain();
+	const logger = createLogger('TransactionOperations');
+
+	const switchChain = async (chainId: number) => {
+		logger.debug('Switching chain', { targetChainId: chainId });
+
+		try {
+			await switchChainAsync({ chainId });
+			logger.info('Chain switch successful', { chainId });
+		} catch (e) {
+			const error = e as Error;
+			logger.error('Chain switch failed', error);
+
+			if (error.name === 'UserRejectedRequestError') {
+				throw new UserRejectedRequestError();
+			}
+			throw new ChainSwitchError(0, chainId);
+		}
+	};
+
+	const signMessage = async (stepItem: SignatureStep) => {
+		try {
+			if (stepItem.id === StepType.signEIP191) {
+				logger.debug('Signing with EIP-191', { data: stepItem.data });
+				const message = isHex(stepItem.data)
+					? { raw: stepItem.data }
+					: stepItem.data;
+				return await signMessageAsync({ message });
+			}
+			if (stepItem.id === StepType.signEIP712) {
+				logger.debug('Signing with EIP-712', {
+					domain: stepItem.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,
+				});
+			}
+		} catch (e) {
+			const error = e as TransactionSignatureError;
+			logger.error('Signature failed', error);
+
+			if (error.cause instanceof BaseError) {
+				const viemError = error.cause as BaseError;
+				if (viemError instanceof ViemUserRejectedRequestError) {
+					throw new UserRejectedRequestError();
+				}
+			}
+
+			throw new TransactionSignatureError(stepItem.id, error as Error);
+		}
+	};
+
+	const sendTransaction = async (
+		chainId: number,
+		stepItem: TransactionStep,
+	): Promise<Hex> => {
+		logger.debug('Sending transaction', {
+			chainId,
+			to: stepItem.to,
+			value: stepItem.value,
+		});
+
+		try {
+			return await sendTransactionAsync({
+				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),
+				}),
+			});
+		} catch (e) {
+			const error = e as TransactionExecutionError;
+			logger.error('Transaction failed', error);
+
+			if (error.cause instanceof BaseError) {
+				const viemError = error.cause as BaseError;
+				if (viemError instanceof ViemUserRejectedRequestError) {
+					throw new UserRejectedRequestError();
+				}
+			}
+
+			throw new TransactionExecutionError(
+				stepItem.id || 'unknown',
+				error as Error,
+			);
+		}
+	};
+
+	return {
+		switchChain,
+		signMessage,
+		sendTransaction,
+	};
+};
+
+export const useOrderSteps = () => {
+	const { switchChain, signMessage, sendTransaction } =
+		useTransactionOperations();
+
+	const currentChainId = useChainId();
+
+	const executeStep = async ({
+		step,
+		chainId,
+	}: {
+		step: Step;
+		chainId: number;
+	}) => {
+		if (chainId !== currentChainId) {
+			await switchChain(chainId);
+		}
+
+		let result: Hex | undefined;
+
+		switch (step.id) {
+			case StepType.signEIP191:
+				result = await signMessage(step as SignatureStep);
+				break;
+			case StepType.signEIP712:
+				result = await signMessage(step as SignatureStep);
+				break;
+			case StepType.buy:
+			case StepType.sell:
+			case StepType.tokenApproval:
+			case StepType.createListing:
+			case StepType.createOffer:
+			case StepType.cancel:
+				result = await sendTransaction(chainId, step as TransactionStep);
+				break;
+			case StepType.unknown:
+				throw new Error('Unknown step type');
+			default: {
+				const _exhaustiveCheck: never = step.id;
+				console.error(_exhaustiveCheck);
+			}
+		}
+
+		return result;
+	};
+
+	return {
+		executeStep,
+	};
+};

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

@@ -0,0 +1,272 @@
+import { renderHook } from '@test';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { useSendTransaction, useSignMessage, useSignTypedData } from 'wagmi';
+import { ExecuteType, StepType } from '../../_internal/api';
+import { useProcessStep } from './useProcessStep';
+
+vi.mock('wagmi', async (importOriginal) => {
+	const actual = await importOriginal();
+	return {
+		// @ts-ignore - ignore spread type error
+		...actual,
+		useSendTransaction: vi.fn(),
+		useSignMessage: vi.fn(),
+		useSignTypedData: vi.fn(),
+	};
+});
+
+vi.mock('../../_internal/api', async (importOriginal) => {
+	const actual = await importOriginal();
+	return {
+		// @ts-ignore - ignore spread type error
+		...actual,
+		getMarketplaceClient: vi.fn(() => ({
+			execute: vi.fn(),
+		})),
+	};
+});
+
+describe('useProcessStep', () => {
+	const mockSendTransactionAsync = vi.fn();
+	const mockSignMessageAsync = vi.fn();
+	const mockSignTypedDataAsync = vi.fn();
+	const mockExecute = vi.fn();
+
+	beforeEach(async () => {
+		vi.clearAllMocks();
+
+		vi.mocked(useSendTransaction).mockReturnValue({
+			sendTransactionAsync: mockSendTransactionAsync,
+		} as any);
+
+		vi.mocked(useSignMessage).mockReturnValue({
+			signMessageAsync: mockSignMessageAsync,
+		} as any);
+
+		vi.mocked(useSignTypedData).mockReturnValue({
+			signTypedDataAsync: mockSignTypedDataAsync,
+		} as any);
+
+		const api = await import('../../_internal/api');
+		vi.mocked(api.getMarketplaceClient).mockReturnValue({
+			execute: mockExecute,
+		} as any);
+	});
+
+	describe('transaction steps', () => {
+		it('should process a buy transaction step', async () => {
+			const mockHash = '0x123abc';
+			mockSendTransactionAsync.mockResolvedValue(mockHash);
+
+			const { result } = renderHook(() => useProcessStep());
+
+			const step = {
+				id: StepType.buy,
+				to: '0x123',
+				data: '0xabc',
+				value: '0x0',
+				price: '0x0',
+			};
+
+			const response = await result.current.processStep(step, 1);
+
+			expect(response).toEqual({ type: 'transaction', hash: mockHash });
+			expect(mockSendTransactionAsync).toHaveBeenCalledWith({
+				chainId: 1,
+				to: '0x123',
+				data: '0xabc',
+				value: 0n,
+			});
+		});
+
+		it('should process a token approval step', async () => {
+			const mockHash = '0x456def';
+			mockSendTransactionAsync.mockResolvedValue(mockHash);
+
+			const { result } = renderHook(() => useProcessStep());
+
+			const step = {
+				id: StepType.tokenApproval,
+				to: '0x456',
+				data: '0xdef',
+				value: '0x0',
+				price: '0x0',
+			};
+
+			const response = await result.current.processStep(step, 1);
+
+			expect(response).toEqual({ type: 'transaction', hash: mockHash });
+		});
+
+		it('should handle gas parameters', async () => {
+			const mockHash = '0x789ghi';
+			mockSendTransactionAsync.mockResolvedValue(mockHash);
+
+			const { result } = renderHook(() => useProcessStep());
+
+			const step = {
+				id: StepType.sell,
+				to: '0x789',
+				data: '0xghi',
+				value: '0x0',
+				price: '0x0',
+				maxFeePerGas: '0x100',
+				maxPriorityFeePerGas: '0x50',
+				gas: '0x5208',
+			};
+
+			await result.current.processStep(step, 1);
+
+			expect(mockSendTransactionAsync).toHaveBeenCalledWith({
+				chainId: 1,
+				to: '0x789',
+				data: '0xghi',
+				value: 0n,
+				maxFeePerGas: 256n,
+				maxPriorityFeePerGas: 80n,
+				gas: 21000n,
+			});
+		});
+	});
+
+	describe('signature steps', () => {
+		it('should process EIP191 signature with API call', async () => {
+			const mockSignature = '0xsignature191';
+			const mockOrderId = 'order-123';
+			mockSignMessageAsync.mockResolvedValue(mockSignature);
+			mockExecute.mockResolvedValue({ orderId: mockOrderId });
+
+			const { result } = renderHook(() => useProcessStep());
+
+			const step = {
+				id: StepType.signEIP191,
+				data: 'Sign this message',
+				to: '0x0',
+				value: '0x0',
+				price: '0x0',
+				post: {
+					endpoint: '/api/order',
+					method: 'POST',
+					body: { test: 'data' },
+				},
+			};
+
+			const response = await result.current.processStep(step, 1);
+
+			expect(response).toEqual({ type: 'signature', orderId: mockOrderId });
+			expect(mockSignMessageAsync).toHaveBeenCalledWith({
+				message: 'Sign this message',
+			});
+			expect(mockExecute).toHaveBeenCalledWith({
+				chainId: '1',
+				signature: mockSignature,
+				method: 'POST',
+				endpoint: '/api/order',
+				body: { test: 'data' },
+				executeType: ExecuteType.order,
+			});
+		});
+
+		it('should process EIP712 signature with API call', async () => {
+			const mockSignature = '0xsignature712';
+			const mockOrderId = 'order-456';
+			mockSignTypedDataAsync.mockResolvedValue(mockSignature);
+			mockExecute.mockResolvedValue({ orderId: mockOrderId });
+
+			const { result } = renderHook(() => useProcessStep());
+
+			const step = {
+				id: StepType.signEIP712,
+				data: '0x0',
+				to: '0x0',
+				value: '0x0',
+				price: '0x0',
+				signature: {
+					domain: {
+						name: 'Test',
+						version: '1',
+						chainId: 1,
+						verifyingContract: '0x0000000000000000000000000000000000000000',
+					},
+					types: { Test: [{ name: 'data', type: 'string' }] },
+					primaryType: 'Test',
+					value: { data: 'test' },
+				},
+				post: {
+					endpoint: '/api/order',
+					method: 'POST',
+					body: { test: 'data' },
+				},
+			};
+
+			const response = await result.current.processStep(step, 1);
+
+			expect(response).toEqual({ type: 'signature', orderId: mockOrderId });
+			expect(mockSignTypedDataAsync).toHaveBeenCalledWith({
+				domain: {
+					name: 'Test',
+					version: '1',
+					chainId: 1,
+					verifyingContract: '0x0000000000000000000000000000000000000000',
+				},
+				types: { Test: [{ name: 'data', type: 'string' }] },
+				primaryType: 'Test',
+				message: { data: 'test' },
+			});
+		});
+
+		it('should handle signature without post step', async () => {
+			const mockSignature = '0xsignatureonly';
+			mockSignMessageAsync.mockResolvedValue(mockSignature);
+
+			const { result } = renderHook(() => useProcessStep());
+
+			const step = {
+				id: StepType.signEIP191,
+				data: '0xabc',
+				to: '0x0',
+				value: '0x0',
+				price: '0x0',
+			};
+
+			const response = await result.current.processStep(step, 1);
+
+			expect(response).toEqual({ type: 'signature', signature: mockSignature });
+			expect(mockExecute).not.toHaveBeenCalled();
+		});
+	});
+
+	describe('error handling', () => {
+		it('should throw error for unsupported step type', async () => {
+			const { result } = renderHook(() => useProcessStep());
+
+			const step = {
+				id: 'unsupported' as any,
+				data: '0x0',
+				to: '0x0',
+				value: '0x0',
+				price: '0x0',
+			};
+
+			await expect(result.current.processStep(step, 1)).rejects.toThrow(
+				'Unsupported step type: unsupported',
+			);
+		});
+
+		it('should throw error for EIP712 without signature data', async () => {
+			const { result } = renderHook(() => useProcessStep());
+
+			const step = {
+				id: StepType.signEIP712,
+				data: '0x0',
+				to: '0x0',
+				value: '0x0',
+				price: '0x0',
+			};
+
+			await expect(result.current.processStep(step, 1)).rejects.toThrow(
+				'EIP712 step missing signature data',
+			);
+		});
+	});
+});