@0xsequence/marketplace-sdk 0.5.6 → 0.5.7

package/src/react/_internal/wallet/__tests__/wallet.test.ts

@@ -0,0 +1,343 @@
+import {
+	type Account,
+	type Address,
+	type Chain,
+	type PublicClient,
+	type WalletClient,
+	hexToBigInt,
+} from 'viem';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import type { Connector } from 'wagmi';
+import type { SdkConfig } from '../../../../types';
+import {
+	ChainSwitchError,
+	TransactionExecutionError,
+	TransactionSignatureError,
+	UserRejectedRequestError,
+} from '../../../../utils/_internal/error/transaction';
+import { StepType, WalletKind } from '../../api';
+import { mockIndexerHandler } from '../../api/__mocks__/indexer.msw';
+import { mockMetadataHandler } from '../../api/__mocks__/metadata.msw';
+import { server } from '../../test/setup';
+import type { SignatureStep, TransactionStep } from '../../utils';
+import { wallet } from '../wallet';
+
+describe('wallet', () => {
+	const mockChains = [
+		{ id: 1, name: 'Ethereum' },
+		{ id: 137, name: 'Polygon' },
+	] as unknown as readonly [Chain, ...Chain[]];
+
+	const mockAddress = '0x1234567890123456789012345678901234567890' as Address;
+	const mockAccount: Account = {
+		address: mockAddress,
+		type: 'json-rpc',
+	};
+
+	const mockConnector = {
+		id: 'sequence',
+		name: 'Sequence',
+		type: 'injected',
+		connect: vi.fn(),
+		disconnect: vi.fn(),
+		getAccount: vi.fn(),
+		getAccounts: vi.fn(),
+		getChainId: vi.fn(),
+		getProvider: vi.fn(),
+		isAuthorized: vi.fn(),
+		onAccountsChanged: vi.fn(),
+		onChainChanged: vi.fn(),
+		onDisconnect: vi.fn(),
+	} as unknown as Connector;
+
+	const mockTransport = {
+		key: 'mock',
+		name: 'Mock Transport',
+		request: vi.fn(),
+		type: 'mock',
+	};
+
+	const mockWalletClient = {
+		account: mockAccount,
+		transport: mockTransport,
+		type: 'walletClient',
+		chain: mockChains[0],
+		uid: 'test-uid',
+		key: 'mock',
+		name: 'Mock Wallet',
+		cacheTime: 0,
+		pollingInterval: 0,
+		request: vi.fn(),
+		extend: vi.fn(),
+		getChainId: vi.fn().mockResolvedValue(1),
+		getAddresses: vi.fn().mockResolvedValue([mockAddress]),
+		switchChain: vi.fn(),
+		signMessage: vi.fn(),
+		signTypedData: vi.fn(),
+		sendTransaction: vi.fn(),
+		signTransaction: vi.fn(),
+		addChain: vi.fn(),
+		deployContract: vi.fn(),
+		getPermissions: vi.fn(),
+		requestAddresses: vi.fn(),
+		requestPermissions: vi.fn(),
+		watchAsset: vi.fn(),
+		writeContract: vi.fn(),
+		prepareTransactionRequest: vi.fn(),
+		sendRawTransaction: vi.fn(),
+	} as unknown as WalletClient & { account: Account };
+
+	const mockSdkConfig: SdkConfig = {
+		projectAccessKey: 'test-key',
+		projectId: 'test-project',
+	};
+
+	const mockPublicClient = {
+		readContract: vi.fn(),
+	} as unknown as PublicClient;
+
+	let walletInstance: ReturnType<typeof wallet>;
+
+	beforeEach(() => {
+		walletInstance = wallet({
+			wallet: mockWalletClient,
+			chains: mockChains,
+			connector: mockConnector,
+			sdkConfig: mockSdkConfig,
+			publicClient: mockPublicClient,
+		});
+	});
+
+	describe('initialization', () => {
+		it('should create wallet instance with correct properties', () => {
+			expect(walletInstance.transport).toBeDefined();
+			expect(walletInstance.isWaaS).toBe(false);
+			expect(walletInstance.walletKind).toBe(WalletKind.sequence);
+		});
+	});
+
+	describe('address', () => {
+		it('should return wallet address', async () => {
+			const address = await walletInstance.address();
+			expect(address).toBe(mockAddress);
+		});
+	});
+
+	describe('switchChain', () => {
+		it('should switch chain successfully', async () => {
+			await walletInstance.switchChain(137);
+			expect(mockWalletClient.switchChain).toHaveBeenCalledWith({ id: 137 });
+		});
+
+		it('should throw ChainSwitchError on unsupported chain switch', async () => {
+			vi.mocked(mockWalletClient.switchChain).mockRejectedValueOnce({
+				name: 'SwitchChainNotSupportedError',
+			});
+			await expect(walletInstance.switchChain(137)).rejects.toThrow(
+				ChainSwitchError,
+			);
+		});
+
+		it('should throw UserRejectedRequestError when user rejects chain switch', async () => {
+			vi.mocked(mockWalletClient.switchChain).mockRejectedValueOnce({
+				name: 'UserRejectedRequestError',
+			});
+			await expect(walletInstance.switchChain(137)).rejects.toThrow(
+				UserRejectedRequestError,
+			);
+		});
+	});
+
+	describe('handleSignMessageStep', () => {
+		const mockSignatureStep: SignatureStep = {
+			id: StepType.signEIP191,
+			data: '0xmessage',
+			to: '0x456' as Address,
+			value: '0x0',
+			price: '0x0',
+			post: {
+				endpoint: '/api/test',
+				method: 'POST',
+				body: {},
+			},
+		};
+
+		it('should handle EIP-191 signature', async () => {
+			// Add MSW handler for any API calls that might happen during signing
+			server.use(
+				mockIndexerHandler('GetTokenBalances', {
+					page: { page: 1, pageSize: 10, more: false },
+					balances: [],
+				}),
+			);
+
+			const mockSignature = '0xsignature';
+			vi.mocked(mockWalletClient.signMessage).mockResolvedValueOnce(
+				mockSignature,
+			);
+
+			const result =
+				await walletInstance.handleSignMessageStep(mockSignatureStep);
+
+			expect(result).toBe(mockSignature);
+			expect(mockWalletClient.signMessage).toHaveBeenCalled();
+		});
+
+		it('should handle EIP-712 signature', async () => {
+			const mockEip712Step: SignatureStep & {
+				signature: NonNullable<SignatureStep['signature']>;
+			} = {
+				id: StepType.signEIP712,
+				data: '0x',
+				to: '0x456' as Address,
+				price: '0x0',
+				value: '0x0',
+				post: {
+					endpoint: '/api/test',
+					method: 'POST',
+					body: {},
+				},
+				signature: {
+					domain: {
+						name: 'Test Domain',
+						version: '1',
+						chainId: 1,
+						verifyingContract: '0x123' as Address,
+					},
+					types: {},
+					primaryType: 'Mail',
+					value: {},
+				},
+			};
+
+			// Add specific handler for EIP-712 signing
+			server.use(
+				mockMetadataHandler('GetContractInfo', {
+					contractInfo: {
+						address: mockEip712Step.signature.domain.verifyingContract,
+						chainId: mockEip712Step.signature.domain.chainId,
+						name: mockEip712Step.signature.domain.name,
+						type: 'ERC721',
+					},
+				}),
+			);
+
+			const mockSignature = '0xsignature';
+			vi.mocked(mockWalletClient.signTypedData).mockResolvedValueOnce(
+				mockSignature,
+			);
+
+			const result = await walletInstance.handleSignMessageStep(mockEip712Step);
+
+			expect(result).toBe(mockSignature);
+			expect(mockWalletClient.signTypedData).toHaveBeenCalled();
+		});
+
+		it('should throw TransactionSignatureError on signature failure', async () => {
+			vi.mocked(mockWalletClient.signMessage).mockRejectedValueOnce(
+				new Error('Signature failed'),
+			);
+
+			await expect(
+				walletInstance.handleSignMessageStep(mockSignatureStep),
+			).rejects.toThrow(TransactionSignatureError);
+		});
+	});
+
+	describe('handleSendTransactionStep', () => {
+		const mockTxStep: TransactionStep = {
+			id: StepType.buy,
+			to: '0x456' as Address,
+			value: '0x0',
+			data: '0x',
+			price: '0x0',
+		};
+
+		it('should send transaction successfully', async () => {
+			// Add MSW handler for transaction-related API calls
+			server.use(
+				mockIndexerHandler('FetchTransactionReceipt', {
+					receipt: {
+						txnHash: '0xtxhash',
+						txnStatus: 'SUCCESSFUL',
+					},
+				}),
+			);
+
+			const mockTxHash = '0xtxhash';
+			vi.mocked(mockWalletClient.sendTransaction).mockResolvedValueOnce(
+				mockTxHash,
+			);
+
+			const result = await walletInstance.handleSendTransactionStep(
+				1,
+				mockTxStep,
+			);
+
+			expect(result).toBe(mockTxHash);
+			expect(mockWalletClient.sendTransaction).toHaveBeenCalledWith(
+				expect.objectContaining({
+					to: mockTxStep.to,
+					value: hexToBigInt('0x0'),
+				}),
+			);
+		});
+
+		it('should throw TransactionExecutionError on transaction failure', async () => {
+			vi.mocked(mockWalletClient.sendTransaction).mockRejectedValueOnce(
+				new Error('Transaction failed'),
+			);
+
+			await expect(
+				walletInstance.handleSendTransactionStep(1, mockTxStep),
+			).rejects.toThrow(TransactionExecutionError);
+		});
+
+		it('should handle transaction with contract interaction', async () => {
+			const mockContractTxStep: TransactionStep = {
+				id: StepType.buy,
+				to: '0x456' as Address,
+				price: '0x0',
+				value: '0x0',
+				data: '0x123456', // Mock contract interaction data
+			};
+
+			// Add handlers for contract-related API calls
+			server.use(
+				mockIndexerHandler('FetchTransactionReceipt', {
+					receipt: {
+						txnHash: '0xtxhash',
+						txnStatus: 'SUCCESSFUL',
+						logs: [],
+					},
+				}),
+				mockMetadataHandler('GetContractInfo', {
+					contractInfo: {
+						address: mockContractTxStep.to,
+						chainId: 1,
+						name: 'Test Contract',
+						type: 'ERC721',
+					},
+				}),
+			);
+
+			const mockTxHash = '0xtxhash';
+			vi.mocked(mockWalletClient.sendTransaction).mockResolvedValueOnce(
+				mockTxHash,
+			);
+
+			const result = await walletInstance.handleSendTransactionStep(
+				1,
+				mockContractTxStep,
+			);
+
+			expect(result).toBe(mockTxHash);
+			expect(mockWalletClient.sendTransaction).toHaveBeenCalledWith(
+				expect.objectContaining({
+					to: mockContractTxStep.to,
+					data: mockContractTxStep.data,
+				}),
+			);
+		});
+	});
+});

package/src/react/_internal/wallet/useWallet.ts

@@ -1,7 +1,13 @@
-import { useAccount, useChainId, useSwitchChain, useWalletClient } from 'wagmi';
-import { useQuery } from '@tanstack/react-query';
-import { wallet, type WalletInstance } from './wallet';
+import { skipToken, useQuery } from '@tanstack/react-query';
+import {
+	useAccount,
+	useChainId,
+	usePublicClient,
+	useSwitchChain,
+	useWalletClient,
+} from 'wagmi';
 import { useConfig } from '../../hooks';
+import { type WalletInstance, wallet } from './wallet';
 
 type UseWalletReturn = {
 	wallet: WalletInstance | null | undefined;
@@ -16,22 +22,23 @@ export const useWallet = (): UseWalletReturn => {
 	const { connector, isConnected, isConnecting } = useAccount();
 	const sdkConfig = useConfig();
 	const chainId = useChainId();
+	const publicClient = usePublicClient();
 
 	const { data, isLoading, isError } = useQuery({
 		queryKey: ['wallet', chainId, connector?.uid],
-		queryFn: () => {
-			if (!walletClient || !connector || !isConnected) {
-				return null;
-			}
-			return wallet({
-				wallet: walletClient,
-				chains,
-				connector,
-				sdkConfig,
-			});
-		},
+		queryFn:
+			walletClient && connector && isConnected && publicClient
+				? () => {
+						return wallet({
+							wallet: walletClient,
+							chains,
+							connector,
+							sdkConfig,
+							publicClient,
+						});
+					}
+				: skipToken,
 		staleTime: Number.POSITIVE_INFINITY,
-		enabled: Boolean(walletClient && connector && isConnected),
 	});
 
 	return {

package/src/react/_internal/wallet/wallet.ts

@@ -1,8 +1,10 @@
+import type { TransactionReceipt } from '@0xsequence/indexer';
 import {
 	type Account,
 	type Address,
 	type Chain,
 	type Hex,
+	type PublicClient,
 	TransactionReceiptNotFoundError,
 	type TypedDataDomain,
 	type WalletClient as ViemWalletClient,
@@ -15,7 +17,12 @@ import {
 } from 'viem';
 import type { Connector } from 'wagmi';
 import type { SwitchChainErrorType } from 'wagmi/actions';
-import { ERC1155_ABI, getPublicRpcClient } from '../../../utils';
+import {
+	SEQUENCE_MARKET_V1_ADDRESS,
+	SEQUENCE_MARKET_V2_ADDRESS,
+} from '../../../consts';
+import type { SdkConfig } from '../../../types';
+import { ERC1155_ABI } from '../../../utils';
 import {
 	ChainSwitchError,
 	TransactionConfirmationError,
@@ -23,15 +30,9 @@ import {
 	TransactionSignatureError,
 	UserRejectedRequestError,
 } from '../../../utils/_internal/error/transaction';
-import { getIndexerClient, StepType, WalletKind } from '../api';
+import { StepType, WalletKind, getIndexerClient } from '../api';
 import { createLogger } from '../logger';
 import type { SignatureStep, TransactionStep } from '../utils';
-import {
-	SEQUENCE_MARKET_V1_ADDRESS,
-	SEQUENCE_MARKET_V2_ADDRESS,
-} from '../../../consts';
-import type { SdkConfig } from '../../../types';
-import type { TransactionReceipt } from '@0xsequence/indexer';
 
 interface WalletClient extends Omit<ViemWalletClient, 'account'> {
 	account: Account;
@@ -65,11 +66,13 @@ export const wallet = ({
 	chains,
 	connector,
 	sdkConfig,
+	publicClient,
 }: {
 	wallet: WalletClient;
 	chains: readonly [Chain, ...Chain[]];
 	connector: Connector;
 	sdkConfig: SdkConfig;
+	publicClient: PublicClient;
 }): WalletInstance => {
 	const logger = createLogger('Wallet');
 
@@ -202,7 +205,6 @@ export const wallet = ({
 			contractAddress: Address;
 			spender: Address | 'sequenceMarketV1' | 'sequenceMarketV2';
 		}) => {
-			const publicClient = getPublicRpcClient(await wallet.getChainId());
 			const walletAddress = await walletInstance.address();
 			const spenderAddress =
 				spender === 'sequenceMarketV1'

package/src/react/hooks/__tests__/useBalanceOfCollectible.test.tsx

@@ -1,21 +1,13 @@
-import { describe, expect, it, beforeEach, vi } from 'vitest';
-import { renderHook, waitFor } from '../../_internal/test-utils';
-import { useBalanceOfCollectible } from '../useBalanceOfCollectible';
-import {
-	mockTokenBalance,
-	enableDebug,
-} from '../../_internal/api/__mocks__/indexer.msw';
-import { zeroAddress } from 'viem';
-import { server } from '../../_internal/test/setup';
 import { http, HttpResponse } from 'msw';
+import { zeroAddress } from 'viem';
+import { describe, expect, it } from 'vitest';
+import { mockTokenBalance } from '../../_internal/api/__mocks__/indexer.msw';
 import { mockIndexerEndpoint } from '../../_internal/api/__mocks__/indexer.msw';
+import { renderHook, waitFor } from '../../_internal/test-utils';
+import { server } from '../../_internal/test/setup';
+import { useBalanceOfCollectible } from '../useBalanceOfCollectible';
 
 describe('useBalanceOfCollectible', () => {
-	beforeEach(() => {
-		vi.clearAllMocks();
-		enableDebug();
-	});
-
 	const defaultArgs = {
 		collectionAddress: zeroAddress,
 		collectableId: '1',