@0xsequence/marketplace-sdk 0.9.0 → 1.0.0

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

@@ -1,313 +0,0 @@
-import type { TransactionReceipt } from '@0xsequence/indexer';
-import {
-	type Account,
-	type Address,
-	BaseError,
-	type Chain,
-	custom,
-	erc20Abi,
-	erc721Abi,
-	type Hex,
-	hexToBigInt,
-	isHex,
-	type PublicClient,
-	TransactionReceiptNotFoundError,
-	type TypedDataDomain,
-	UserRejectedRequestError as ViemUserRejectedRequestError,
-	type WalletClient as ViemWalletClient,
-	WaitForTransactionReceiptTimeoutError,
-} from 'viem';
-import type { Connector } from 'wagmi';
-import type { SwitchChainErrorType } from 'wagmi/actions';
-import {
-	SEQUENCE_MARKET_V1_ADDRESS,
-	SEQUENCE_MARKET_V2_ADDRESS,
-} from '../../../consts';
-import type { SdkConfig } from '../../../types';
-import { ERC1155_ABI } from '../../../utils';
-import {
-	ChainSwitchError,
-	TransactionConfirmationError,
-	TransactionExecutionError,
-	TransactionSignatureError,
-	UserRejectedRequestError,
-} from '../../../utils/_internal/error/transaction';
-import { getIndexerClient, StepType, WalletKind } from '../api';
-import { createLogger } from '../logger';
-import type { SignatureStep, TransactionStep } from '../utils';
-
-interface WalletClient extends Omit<ViemWalletClient, 'account'> {
-	account: Account;
-}
-
-export interface WalletInstance {
-	transport: ReturnType<typeof custom>;
-	isWaaS: boolean;
-	walletKind: WalletKind;
-	getChainId: () => Promise<number>;
-	switchChain: (chainId: number) => Promise<void>;
-	address: () => Promise<Hex>;
-	handleSignMessageStep: (stepItem: SignatureStep) => Promise<Hex | undefined>;
-	handleSendTransactionStep: (
-		chainId: number,
-		stepItem: TransactionStep,
-	) => Promise<Hex>;
-	handleConfirmTransactionStep: (
-		txHash: Hex,
-		chainId: number,
-	) => Promise<TransactionReceipt>;
-	hasTokenApproval: (args: {
-		tokenType: 'ERC20' | 'ERC721' | 'ERC1155';
-		contractAddress: Address;
-		spender: Address | 'sequenceMarketV1' | 'sequenceMarketV2';
-	}) => Promise<bigint | boolean>;
-	publicClient: PublicClient;
-}
-
-const isSequenceWallet = (connector: Connector) =>
-	connector.id === 'sequence' || connector.id === 'sequence-waas';
-
-export const wallet = ({
-	wallet,
-	chains,
-	connector,
-	sdkConfig,
-	publicClient,
-}: {
-	wallet: WalletClient;
-	chains: readonly [Chain, ...Chain[]];
-	connector: Connector;
-	sdkConfig: SdkConfig;
-	publicClient: PublicClient;
-}): WalletInstance => {
-	const logger = createLogger('Wallet');
-
-	const walletInstance = {
-		transport: custom(wallet.transport),
-		isWaaS: connector.id.endsWith('waas'),
-		walletKind: isSequenceWallet(connector)
-			? WalletKind.sequence
-			: WalletKind.unknown,
-		getChainId: wallet.getChainId,
-		address: async () => {
-			let address = wallet.account?.address;
-			if (!address) {
-				[address] = await wallet.getAddresses();
-			}
-			return address;
-		},
-		switchChain: async (chainId: number) => {
-			logger.debug('Switching chain', { targetChainId: chainId });
-
-			try {
-				await wallet.switchChain({
-					id: chainId,
-				});
-				logger.info('Chain switch successful', { chainId });
-				return;
-			} catch (e) {
-				const error = e as SwitchChainErrorType;
-				logger.error('Chain switch failed', error);
-
-				switch (error.name) {
-					case 'SwitchChainNotSupportedError':
-						throw new ChainSwitchError(await wallet.getChainId(), chainId);
-					case 'UserRejectedRequestError':
-						throw new UserRejectedRequestError();
-					case 'ChainNotConfiguredError':
-						return;
-					default:
-						throw new ChainSwitchError(await wallet.getChainId(), chainId);
-				}
-			}
-		},
-		handleSignMessageStep: 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 wallet.signMessage({
-						account: wallet.account,
-						message,
-					});
-				}
-				if (stepItem.id === StepType.signEIP712) {
-					logger.debug('Signing with EIP-712', {
-						domain: stepItem.domain,
-						types: stepItem.signature?.types,
-					});
-					return await wallet.signTypedData({
-						account: wallet.account,
-						// 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);
-			}
-		},
-		handleSendTransactionStep: async (
-			chainId: number,
-			stepItem: TransactionStep,
-		) => {
-			logger.debug('Sending transaction', {
-				chainId,
-				to: stepItem.to,
-				value: stepItem.value,
-			});
-
-			const chain = chains.find((chain) => chain.id === chainId);
-			try {
-				return await wallet.sendTransaction({
-					chain,
-					data: stepItem.data,
-					account: wallet.account,
-					to: stepItem.to,
-					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, error as Error);
-			}
-		},
-		handleConfirmTransactionStep: async (txHash: Hex, chainId: number) => {
-			logger.debug('Confirming transaction', { txHash, chainId });
-			try {
-				const receipt = await awaitTransactionReceipt({
-					txHash,
-					chainId,
-					sdkConfig,
-				});
-				logger.info('Transaction confirmed', { txHash, receipt });
-				return receipt;
-			} catch (error) {
-				logger.error('Transaction confirmation failed', error);
-
-				throw new TransactionConfirmationError(txHash, error as Error);
-			}
-		},
-		hasTokenApproval: async ({
-			tokenType,
-			contractAddress,
-			spender,
-		}: {
-			tokenType: 'ERC20' | 'ERC721' | 'ERC1155';
-			contractAddress: Address;
-			spender: Address | 'sequenceMarketV1' | 'sequenceMarketV2';
-		}) => {
-			const walletAddress = await walletInstance.address();
-			const spenderAddress =
-				spender === 'sequenceMarketV1'
-					? SEQUENCE_MARKET_V1_ADDRESS
-					: spender === 'sequenceMarketV2'
-						? SEQUENCE_MARKET_V2_ADDRESS
-						: spender;
-
-			switch (tokenType) {
-				case 'ERC20':
-					return (await publicClient.readContract({
-						address: contractAddress as Hex,
-						abi: erc20Abi,
-						functionName: 'allowance',
-						args: [walletAddress, spenderAddress],
-					})) as bigint;
-				case 'ERC721':
-					return (await publicClient.readContract({
-						address: contractAddress as Hex,
-						abi: erc721Abi,
-						functionName: 'isApprovedForAll',
-						args: [walletAddress, spenderAddress],
-					})) as boolean;
-				case 'ERC1155':
-					return (await publicClient.readContract({
-						address: contractAddress as Hex,
-						abi: ERC1155_ABI,
-						functionName: 'isApprovedForAll',
-						args: [walletAddress, spenderAddress],
-					})) as boolean;
-				default:
-					throw new Error('Unsupported contract type for approval checking');
-			}
-		},
-		publicClient,
-	};
-
-	return walletInstance;
-};
-
-const ONE_MIN = 60 * 1000;
-const THREE_MIN = 3 * ONE_MIN;
-
-const awaitTransactionReceipt = async ({
-	txHash,
-	chainId,
-	sdkConfig,
-	timeout = THREE_MIN,
-}: {
-	txHash: Hex;
-	chainId: number;
-	sdkConfig: SdkConfig;
-	timeout?: number;
-}) => {
-	const indexer = getIndexerClient(chainId, sdkConfig);
-	return Promise.race([
-		new Promise<TransactionReceipt>((resolve, reject) => {
-			indexer.subscribeReceipts(
-				{
-					filter: {
-						txnHash: txHash,
-					},
-				},
-				{
-					onMessage: ({ receipt }) => {
-						resolve(receipt);
-					},
-					onError: () => {
-						reject(TransactionReceiptNotFoundError);
-					},
-				},
-			);
-		}),
-		new Promise<TransactionReceipt>((_, reject) => {
-			setTimeout(() => {
-				reject(WaitForTransactionReceiptTimeoutError);
-			}, timeout);
-		}),
-	]);
-};

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

@@ -1,104 +0,0 @@
-import { renderHook, server, waitFor } from '@test';
-import { HttpResponse, http } from 'msw';
-import { describe, expect, it } from 'vitest';
-import { useGetTokenSuppliesMap } from '../useGetTokenSuppliesMap';
-
-describe('useGetTokenSuppliesMap', () => {
-	const defaultParams = {
-		chainId: 1,
-		collectionAddress: '0x1234567890123456789012345678901234567890',
-		tokenIds: ['1', '2', '3'],
-	};
-
-	const mockTokenSuppliesMap = {
-		supplies: {
-			[defaultParams.collectionAddress]: [
-				{
-					tokenID: '1',
-					supply: '100',
-				},
-				{
-					tokenID: '2',
-					supply: '250',
-				},
-				{
-					tokenID: '3',
-					supply: '50',
-				},
-			],
-		},
-	};
-
-	it('should fetch token supplies map successfully', async () => {
-		// Mock the indexer API response
-		server.use(
-			http.post('*/rpc/Indexer/GetTokenSuppliesMap', () => {
-				return HttpResponse.json(mockTokenSuppliesMap);
-			}),
-		);
-
-		const { result } = renderHook(() => useGetTokenSuppliesMap(defaultParams));
-
-		// Initially loading
-		expect(result.current.isLoading).toBe(true);
-		expect(result.current.data).toBeUndefined();
-
-		// Wait for data to be loaded
-		await waitFor(() => {
-			expect(result.current.isLoading).toBe(false);
-		});
-
-		// Verify the data matches our mock
-		expect(result.current.data).toEqual(mockTokenSuppliesMap);
-		expect(result.current.error).toBeNull();
-	});
-
-	it('should handle empty token IDs', async () => {
-		const emptyParams = {
-			...defaultParams,
-			tokenIds: [],
-		};
-
-		const { result } = renderHook(() => useGetTokenSuppliesMap(emptyParams));
-
-		// Should not trigger request with empty token IDs
-		expect(result.current.isLoading).toBe(false);
-		expect(result.current.data).toBeUndefined();
-		expect(result.current.error).toBeNull();
-	});
-
-	it('should handle disabled queries', async () => {
-		const disabledParams = {
-			...defaultParams,
-			query: {
-				enabled: false,
-			},
-		};
-
-		const { result } = renderHook(() => useGetTokenSuppliesMap(disabledParams));
-
-		// For disabled queries, we expect no loading state and no data
-		expect(result.current.isLoading).toBe(false);
-		expect(result.current.data).toBeUndefined();
-		expect(result.current.error).toBeNull();
-	});
-
-	it('should handle API errors', async () => {
-		// Mock API error
-		server.use(
-			http.post('*/rpc/Indexer/GetTokenSuppliesMap', () => {
-				return new HttpResponse(null, { status: 500 });
-			}),
-		);
-
-		const { result } = renderHook(() => useGetTokenSuppliesMap(defaultParams));
-
-		// Wait for error state
-		await waitFor(() => {
-			expect(result.current.isLoading).toBe(false);
-		});
-
-		expect(result.current.data).toBeUndefined();
-		expect(result.current.error).toBeTruthy();
-	});
-});

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

@@ -1,111 +0,0 @@
-import { renderHook, server, waitFor } from '@test';
-import { HttpResponse, http } from 'msw';
-import { describe, expect, it } from 'vitest';
-import { useListTokenMetadata } from '../useListTokenMetadata';
-
-describe('useListTokenMetadata', () => {
-	const defaultParams = {
-		chainId: 1,
-		contractAddress: '0x1234567890123456789012345678901234567890',
-		tokenIds: ['1', '2', '3'],
-	};
-
-	const mockTokenMetadata = [
-		{
-			tokenId: '1',
-			contractAddress: '0x1234567890123456789012345678901234567890',
-			name: 'Token 1',
-			description: 'First token',
-			image: 'https://example.com/1.png',
-		},
-		{
-			tokenId: '2',
-			contractAddress: '0x1234567890123456789012345678901234567890',
-			name: 'Token 2',
-			description: 'Second token',
-			image: 'https://example.com/2.png',
-		},
-		{
-			tokenId: '3',
-			contractAddress: '0x1234567890123456789012345678901234567890',
-			name: 'Token 3',
-			description: 'Third token',
-			image: 'https://example.com/3.png',
-		},
-	];
-
-	it('should fetch token metadata successfully', async () => {
-		// Mock the metadata API response
-		server.use(
-			http.post('*/rpc/Metadata/GetTokenMetadata', () => {
-				return HttpResponse.json({
-					tokenMetadata: mockTokenMetadata,
-				});
-			}),
-		);
-
-		const { result } = renderHook(() => useListTokenMetadata(defaultParams));
-
-		// Initially loading
-		expect(result.current.isLoading).toBe(true);
-		expect(result.current.data).toBeUndefined();
-
-		// Wait for data to be loaded
-		await waitFor(() => {
-			expect(result.current.isLoading).toBe(false);
-		});
-
-		// Verify the data matches our mock
-		expect(result.current.data).toEqual(mockTokenMetadata);
-		expect(result.current.error).toBeNull();
-	});
-
-	it('should handle empty token IDs', async () => {
-		const emptyParams = {
-			...defaultParams,
-			tokenIds: [],
-		};
-
-		const { result } = renderHook(() => useListTokenMetadata(emptyParams));
-
-		// Should not trigger request with empty token IDs
-		expect(result.current.isLoading).toBe(false);
-		expect(result.current.data).toBeUndefined();
-		expect(result.current.error).toBeNull();
-	});
-
-	it('should handle disabled queries', async () => {
-		const disabledParams = {
-			...defaultParams,
-			query: {
-				enabled: false,
-			},
-		};
-
-		const { result } = renderHook(() => useListTokenMetadata(disabledParams));
-
-		// For disabled queries, we expect no loading state and no data
-		expect(result.current.isLoading).toBe(false);
-		expect(result.current.data).toBeUndefined();
-		expect(result.current.error).toBeNull();
-	});
-
-	it('should handle API errors', async () => {
-		// Mock API error
-		server.use(
-			http.post('*/rpc/Metadata/GetTokenMetadata', () => {
-				return new HttpResponse(null, { status: 500 });
-			}),
-		);
-
-		const { result } = renderHook(() => useListTokenMetadata(defaultParams));
-
-		// Wait for error state
-		await waitFor(() => {
-			expect(result.current.isLoading).toBe(false);
-		});
-
-		expect(result.current.data).toBeUndefined();
-		expect(result.current.error).toBeTruthy();
-	});
-});

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

@@ -1 +0,0 @@
-export * from '../../queries/marketplaceConfig';