@0xsequence/marketplace-sdk 0.9.0 → 1.0.0

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

@@ -0,0 +1,95 @@
+import { type Hex, hexToBigInt, isHex, type TypedDataDomain } from 'viem';
+import { useSendTransaction, useSignMessage, useSignTypedData } from 'wagmi';
+import {
+	ExecuteType,
+	getMarketplaceClient,
+	type Step,
+	StepType,
+} from '../../_internal/api';
+import { isSignatureStep, isTransactionStep } from '../../_internal/utils';
+import { useConfig } from '../config';
+
+type ProcessStepResult =
+	| { type: 'transaction'; hash: Hex }
+	| { type: 'signature'; orderId?: string; signature?: Hex };
+
+export const useProcessStep = () => {
+	const { sendTransactionAsync } = useSendTransaction();
+	const { signMessageAsync } = useSignMessage();
+	const { signTypedDataAsync } = useSignTypedData();
+	const config = useConfig();
+	const marketplaceClient = getMarketplaceClient(config);
+
+	const processStep = async (
+		step: Step,
+		chainId: number,
+	): Promise<ProcessStepResult> => {
+		// Transaction steps - return transaction hash
+		if (isTransactionStep(step)) {
+			const hash = await sendTransactionAsync({
+				chainId,
+				to: step.to as Hex,
+				data: step.data as Hex,
+				value: hexToBigInt((step.value as Hex) || '0x0'),
+				...(step.maxFeePerGas && {
+					maxFeePerGas: hexToBigInt(step.maxFeePerGas as Hex),
+				}),
+				...(step.maxPriorityFeePerGas && {
+					maxPriorityFeePerGas: hexToBigInt(step.maxPriorityFeePerGas as Hex),
+				}),
+				...(step.gas && {
+					gas: hexToBigInt(step.gas as Hex),
+				}),
+			});
+
+			return { type: 'transaction', hash };
+		}
+
+		// Signature steps - sign and execute API call
+		if (isSignatureStep(step)) {
+			let signature: Hex | undefined;
+
+			if (step.id === StepType.signEIP191) {
+				const message = isHex(step.data)
+					? { raw: step.data as Hex }
+					: step.data;
+				signature = await signMessageAsync({ message });
+			} else if (step.id === StepType.signEIP712) {
+				if (!step.signature) {
+					throw new Error('EIP712 step missing signature data');
+				}
+				signature = await signTypedDataAsync({
+					domain: step.signature.domain as TypedDataDomain,
+					types: step.signature.types,
+					primaryType: step.signature.primaryType,
+					message: step.signature.value,
+				});
+			}
+
+			if (!signature) {
+				throw new Error('Failed to sign message');
+			}
+
+			// 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,
+				});
+
+				return { type: 'signature', orderId: result.orderId };
+			}
+
+			// Some signature steps might not have post (edge case)
+			return { type: 'signature', signature };
+		}
+
+		throw new Error(`Unsupported step type: ${step.id}`);
+	};
+
+	return { processStep };
+};

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

@@ -0,0 +1,469 @@
+import { renderHook } from '@test';
+import type { Address } from 'viem';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { useAccount, useWriteContract } from 'wagmi';
+import { NoWalletConnectedError } from '../../../utils/_internal/error/transaction';
+import { ContractType } from '../../_internal/api/marketplace.gen';
+import {
+	type TransferTokensParams,
+	useTransferTokens,
+} from './useTransferTokens';
+
+// Mock wagmi hooks
+vi.mock('wagmi', async () => {
+	const actual = await vi.importActual('wagmi');
+	return {
+		...actual,
+		useAccount: vi.fn(),
+		useWriteContract: vi.fn(),
+	};
+});
+
+const mockUseAccount = vi.mocked(useAccount);
+const mockUseWriteContract = vi.mocked(useWriteContract);
+
+describe('useTransferTokens', () => {
+	const mockAccountAddress = '0x742d35Cc6634C0532925a3b8D4C9db96' as Address;
+	const mockReceiverAddress =
+		'0x456789abcdef123456789abcdef123456789abcdef' as Address;
+	const mockCollectionAddress =
+		'0x123456789abcdef123456789abcdef123456789abc' as Address;
+	const mockWriteContractAsync = vi.fn();
+
+	beforeEach(() => {
+		vi.clearAllMocks();
+
+		mockUseAccount.mockReturnValue({
+			address: mockAccountAddress,
+			chainId: 1,
+			addresses: [mockAccountAddress],
+			chain: undefined,
+			connector: undefined,
+			isConnected: true,
+			isConnecting: false,
+			isDisconnected: false,
+			isReconnecting: false,
+			status: 'connected',
+			// biome-ignore lint/suspicious/noExplicitAny: nor mocked the full type
+		} as any);
+
+		mockUseWriteContract.mockReturnValue({
+			writeContractAsync: mockWriteContractAsync,
+			data: undefined,
+			isPending: false,
+			isError: false,
+			isSuccess: false,
+			error: null,
+			status: 'idle',
+			variables: undefined,
+			isIdle: true,
+			reset: vi.fn(),
+			context: undefined,
+			failureCount: 0,
+			failureReason: null,
+			isPaused: false,
+			submittedAt: 0,
+		} as any);
+	});
+
+	describe('Hook Return Values', () => {
+		it('should return correct interface', () => {
+			const { result } = renderHook(() => useTransferTokens());
+
+			expect(result.current).toHaveProperty('transferTokensAsync');
+			expect(result.current).toHaveProperty('hash');
+			expect(result.current).toHaveProperty('transferring');
+			expect(result.current).toHaveProperty('transferFailed');
+			expect(result.current).toHaveProperty('transferSuccess');
+			expect(typeof result.current.transferTokensAsync).toBe('function');
+		});
+
+		it('should return wagmi hook states correctly', () => {
+			mockUseWriteContract.mockReturnValue({
+				writeContractAsync: mockWriteContractAsync,
+				data: '0xhash123' as `0x${string}`,
+				isPending: true,
+				isError: false,
+				isSuccess: false,
+				error: null,
+				status: 'pending',
+				variables: undefined,
+				isIdle: false,
+				reset: vi.fn(),
+				context: undefined,
+				failureCount: 0,
+				failureReason: null,
+				isPaused: false,
+				submittedAt: 0,
+			} as any);
+
+			const { result } = renderHook(() => useTransferTokens());
+
+			expect(result.current.hash).toBe('0xhash123');
+			expect(result.current.transferring).toBe(true);
+			expect(result.current.transferFailed).toBe(false);
+			expect(result.current.transferSuccess).toBe(false);
+		});
+	});
+
+	describe('ERC721 Transfers', () => {
+		const erc721Params: TransferTokensParams = {
+			contractType: ContractType.ERC721,
+			chainId: 1,
+			collectionAddress: mockCollectionAddress,
+			tokenId: '123',
+			receiverAddress: mockReceiverAddress,
+		};
+
+		it('should prepare correct ERC721 transfer config', async () => {
+			mockWriteContractAsync.mockResolvedValue('0xhash123');
+
+			const { result } = renderHook(() => useTransferTokens());
+
+			await result.current.transferTokensAsync(erc721Params);
+
+			expect(mockWriteContractAsync).toHaveBeenCalledWith({
+				abi: expect.any(Array), // erc721Abi
+				address: mockCollectionAddress,
+				functionName: 'safeTransferFrom',
+				args: [mockAccountAddress, mockReceiverAddress, BigInt('123')],
+			});
+		});
+
+		it('should return transaction hash for ERC721', async () => {
+			const expectedHash = '0xabc123def456';
+			mockWriteContractAsync.mockResolvedValue(expectedHash);
+
+			const { result } = renderHook(() => useTransferTokens());
+
+			const hash = await result.current.transferTokensAsync(erc721Params);
+
+			expect(hash).toBe(expectedHash);
+		});
+
+		it('should handle ERC721 transfer errors', async () => {
+			const error = new Error('Transfer failed');
+			mockWriteContractAsync.mockRejectedValue(error);
+
+			const { result } = renderHook(() => useTransferTokens());
+
+			await expect(
+				result.current.transferTokensAsync(erc721Params),
+			).rejects.toThrow('Transfer failed');
+		});
+	});
+
+	describe('ERC1155 Transfers', () => {
+		const erc1155Params: TransferTokensParams = {
+			contractType: ContractType.ERC1155,
+			chainId: 1,
+			collectionAddress: mockCollectionAddress,
+			tokenId: '456',
+			receiverAddress: mockReceiverAddress,
+			quantity: '5',
+		};
+
+		it('should prepare correct ERC1155 transfer config', async () => {
+			mockWriteContractAsync.mockResolvedValue('0xhash456');
+
+			const { result } = renderHook(() => useTransferTokens());
+
+			await result.current.transferTokensAsync(erc1155Params);
+
+			expect(mockWriteContractAsync).toHaveBeenCalledWith({
+				abi: expect.any(Array), // ERC1155_ABI
+				address: mockCollectionAddress,
+				functionName: 'safeTransferFrom',
+				args: [
+					mockAccountAddress,
+					mockReceiverAddress,
+					BigInt('456'),
+					'5',
+					'0x', // data
+				],
+			});
+		});
+
+		it('should return transaction hash for ERC1155', async () => {
+			const expectedHash = '0xdef789ghi012';
+			mockWriteContractAsync.mockResolvedValue(expectedHash);
+
+			const { result } = renderHook(() => useTransferTokens());
+
+			const hash = await result.current.transferTokensAsync(erc1155Params);
+
+			expect(hash).toBe(expectedHash);
+		});
+
+		it('should handle ERC1155 transfer errors', async () => {
+			const error = new Error('ERC1155 transfer failed');
+			mockWriteContractAsync.mockRejectedValue(error);
+
+			const { result } = renderHook(() => useTransferTokens());
+
+			await expect(
+				result.current.transferTokensAsync(erc1155Params),
+			).rejects.toThrow('ERC1155 transfer failed');
+		});
+
+		it('should handle different quantity values', async () => {
+			mockWriteContractAsync.mockResolvedValue('0xhash');
+
+			const { result } = renderHook(() => useTransferTokens());
+
+			// Test with large quantity
+			await result.current.transferTokensAsync({
+				...erc1155Params,
+				quantity: '1000000',
+			});
+
+			expect(mockWriteContractAsync).toHaveBeenCalledWith(
+				expect.objectContaining({
+					args: expect.arrayContaining(['1000000']),
+				}),
+			);
+		});
+	});
+
+	describe('Error Handling', () => {
+		it('should throw NoWalletConnectedError when no account address', async () => {
+			mockUseAccount.mockReturnValue({
+				address: undefined,
+				chainId: 1,
+				addresses: undefined,
+				chain: undefined,
+				connector: undefined,
+				isConnected: false,
+				isConnecting: false,
+				isDisconnected: true,
+				isReconnecting: false,
+				status: 'disconnected',
+			} as any);
+
+			const { result } = renderHook(() => useTransferTokens());
+
+			const erc721Params: TransferTokensParams = {
+				contractType: ContractType.ERC721,
+				chainId: 1,
+				collectionAddress: mockCollectionAddress,
+				tokenId: '123',
+				receiverAddress: mockReceiverAddress,
+			};
+
+			await expect(
+				result.current.transferTokensAsync(erc721Params),
+			).rejects.toThrow(NoWalletConnectedError);
+		});
+
+		it('should not call writeContractAsync when no wallet connected', async () => {
+			mockUseAccount.mockReturnValue({
+				address: undefined,
+				chainId: 1,
+				addresses: undefined,
+				chain: undefined,
+				connector: undefined,
+				isConnected: false,
+				isConnecting: false,
+				isDisconnected: true,
+				isReconnecting: false,
+				status: 'disconnected',
+			} as any);
+
+			const { result } = renderHook(() => useTransferTokens());
+
+			const erc721Params: TransferTokensParams = {
+				contractType: ContractType.ERC721,
+				chainId: 1,
+				collectionAddress: mockCollectionAddress,
+				tokenId: '123',
+				receiverAddress: mockReceiverAddress,
+			};
+
+			try {
+				await result.current.transferTokensAsync(erc721Params);
+			} catch {
+				// Expected to throw
+			}
+
+			expect(mockWriteContractAsync).not.toHaveBeenCalled();
+		});
+	});
+
+	describe('State Updates', () => {
+		it('should reflect isPending state', () => {
+			mockUseWriteContract.mockReturnValue({
+				writeContractAsync: mockWriteContractAsync,
+				data: undefined,
+				isPending: true,
+				isError: false,
+				isSuccess: false,
+				error: null,
+				status: 'pending',
+				variables: undefined,
+				isIdle: false,
+				reset: vi.fn(),
+				context: undefined,
+				failureCount: 0,
+				failureReason: null,
+				isPaused: false,
+				submittedAt: 0,
+			} as any);
+
+			const { result } = renderHook(() => useTransferTokens());
+
+			expect(result.current.transferring).toBe(true);
+		});
+
+		it('should reflect isError state', () => {
+			mockUseWriteContract.mockReturnValue({
+				writeContractAsync: mockWriteContractAsync,
+				data: undefined,
+				isPending: false,
+				isError: true,
+				isSuccess: false,
+				error: new Error('Contract error'),
+				status: 'error',
+				variables: undefined,
+				isIdle: false,
+				reset: vi.fn(),
+				context: undefined,
+				failureCount: 1,
+				failureReason: new Error('Contract error'),
+				isPaused: false,
+				submittedAt: 0,
+			} as any);
+
+			const { result } = renderHook(() => useTransferTokens());
+
+			expect(result.current.transferFailed).toBe(true);
+		});
+
+		it('should reflect isSuccess state', () => {
+			mockUseWriteContract.mockReturnValue({
+				writeContractAsync: mockWriteContractAsync,
+				data: '0xsuccess123' as `0x${string}`,
+				isPending: false,
+				isError: false,
+				isSuccess: true,
+				error: null,
+				status: 'success',
+				variables: undefined,
+				isIdle: false,
+				reset: vi.fn(),
+				context: undefined,
+				failureCount: 0,
+				failureReason: null,
+				isPaused: false,
+				submittedAt: 0,
+			} as any);
+
+			const { result } = renderHook(() => useTransferTokens());
+
+			expect(result.current.transferSuccess).toBe(true);
+			expect(result.current.hash).toBe('0xsuccess123');
+		});
+	});
+
+	describe('Integration with Wagmi Mocks', () => {
+		it('should work with wagmi test configuration', () => {
+			// This test verifies the hook works with our existing wagmi mock setup
+			const { result } = renderHook(() => useTransferTokens(), {
+				useEmbeddedWallet: false, // Use standard mock connector
+			});
+
+			expect(result.current.transferTokensAsync).toBeDefined();
+			expect(typeof result.current.transferTokensAsync).toBe('function');
+		});
+
+		it('should work with WaaS wallet configuration', () => {
+			const { result } = renderHook(() => useTransferTokens(), {
+				useEmbeddedWallet: true, // Use WaaS mock connector
+			});
+
+			expect(result.current.transferTokensAsync).toBeDefined();
+			expect(typeof result.current.transferTokensAsync).toBe('function');
+		});
+	});
+
+	describe('Contract Interaction', () => {
+		it('should handle contract call success', async () => {
+			const expectedHash = '0xcontract123success';
+			mockWriteContractAsync.mockResolvedValue(expectedHash);
+
+			const { result } = renderHook(() => useTransferTokens());
+
+			const erc721Params: TransferTokensParams = {
+				contractType: ContractType.ERC721,
+				chainId: 1,
+				collectionAddress: mockCollectionAddress,
+				tokenId: '789',
+				receiverAddress: mockReceiverAddress,
+			};
+
+			const hash = await result.current.transferTokensAsync(erc721Params);
+
+			expect(hash).toBe(expectedHash);
+			expect(mockWriteContractAsync).toHaveBeenCalledTimes(1);
+		});
+
+		it('should handle contract call failure', async () => {
+			const contractError = new Error('Contract execution reverted');
+			mockWriteContractAsync.mockRejectedValue(contractError);
+
+			const { result } = renderHook(() => useTransferTokens());
+
+			const erc721Params: TransferTokensParams = {
+				contractType: ContractType.ERC721,
+				chainId: 1,
+				collectionAddress: mockCollectionAddress,
+				tokenId: '789',
+				receiverAddress: mockReceiverAddress,
+			};
+
+			await expect(
+				result.current.transferTokensAsync(erc721Params),
+			).rejects.toThrow('Contract execution reverted');
+		});
+	});
+
+	describe('Parameter Validation', () => {
+		it('should handle different token ID formats', async () => {
+			mockWriteContractAsync.mockResolvedValue('0xhash');
+
+			const { result } = renderHook(() => useTransferTokens());
+
+			// Test with string token ID
+			await result.current.transferTokensAsync({
+				contractType: ContractType.ERC721,
+				chainId: 1,
+				collectionAddress: mockCollectionAddress,
+				tokenId: '999999999999999999999',
+				receiverAddress: mockReceiverAddress,
+			});
+
+			expect(mockWriteContractAsync).toHaveBeenCalledWith(
+				expect.objectContaining({
+					args: expect.arrayContaining([BigInt('999999999999999999999')]),
+				}),
+			);
+		});
+
+		it('should handle different chain IDs', async () => {
+			mockWriteContractAsync.mockResolvedValue('0xhash');
+
+			const { result } = renderHook(() => useTransferTokens());
+
+			const polygonParams: TransferTokensParams = {
+				contractType: ContractType.ERC721,
+				chainId: 137, // Polygon
+				collectionAddress: mockCollectionAddress,
+				tokenId: '123',
+				receiverAddress: mockReceiverAddress,
+			};
+
+			await result.current.transferTokensAsync(polygonParams);
+
+			expect(mockWriteContractAsync).toHaveBeenCalled();
+		});
+	});
+});

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

@@ -1,12 +1,12 @@
-import { type Abi, type Address, erc721Abi, type Hex } from 'viem';
+import { type Abi, type Address, erc721Abi } from 'viem';
 import { useAccount, useWriteContract } from 'wagmi';
-import { ERC1155_ABI } from '../../utils';
-import { NoWalletConnectedError } from '../../utils/_internal/error/transaction';
-import type { ContractType } from '../_internal';
+import { ERC1155_ABI } from '../../../utils';
+import { NoWalletConnectedError } from '../../../utils/_internal/error/transaction';
+import type { ContractType } from '../../_internal';
 
 interface BaseTransferParams {
 	chainId: number;
-	collectionAddress: Hex;
+	collectionAddress: Address;
 	tokenId: string;
 	receiverAddress: Address;
 }

package/src/react/hooks/ui/index.ts

@@ -0,0 +1,3 @@
+export * from './useFilterState';
+export * from './useFilters';
+export * from './useOpenConnectModal';

package/src/react/hooks/{useFilterState.tsx → ui/useFilterState.tsx}

@@ -6,7 +6,7 @@ import {
 	useQueryState,
 } from 'nuqs';
 import { useMemo } from 'react';
-import { type PropertyFilter, PropertyType } from '../_internal';
+import { type PropertyFilter, PropertyType } from '../../_internal';
 
 interface StringFilterValues {
 	type: PropertyType.STRING;

package/src/react/hooks/{__tests__ → ui}/useFilters.test.tsx

@@ -3,11 +3,10 @@ import { HttpResponse, http } from 'msw';
 import { zeroAddress } from 'viem';
 import { describe, expect, it } from 'vitest';
 import { mockMetadataEndpoint } from '../../_internal/api/__mocks__/metadata.msw';
-import type { UseFiltersArgs } from '../useFilters';
-import { useFilters } from '../useFilters';
+import { type UseFiltersParams, useFilters } from './useFilters';
 
 describe('useFilters', () => {
-	const defaultArgs: UseFiltersArgs = {
+	const defaultArgs: UseFiltersParams = {
 		chainId: 1,
 		collectionAddress: zeroAddress,
 	};