@0xsequence/marketplace-sdk 0.0.0-20250513233135

package/src/react/_internal/wagmi/get-connectors.ts

@@ -0,0 +1,206 @@
+import {
+	type SequenceOptions,
+	type Wallet,
+	apple,
+	appleWaas,
+	coinbaseWallet,
+	ecosystemWallet,
+	email,
+	emailWaas,
+	facebook,
+	getConnectWallets,
+	google,
+	googleWaas,
+	sequence,
+	twitch,
+	walletConnect,
+} from '@0xsequence/connect';
+import React, { type FunctionComponent } from 'react';
+import type { CreateConnectorFn } from 'wagmi';
+import type { Env, SdkConfig } from '../../../types';
+import { MissingConfigError } from '../../../utils/_internal/error/transaction';
+import type { MarketplaceConfig } from '../../queries/marketplaceConfig';
+import { MarketplaceWallet } from '../api/builder.gen';
+import { DEFAULT_NETWORK } from '../consts';
+
+export function getConnectors({
+	marketplaceConfig,
+	sdkConfig,
+	walletType,
+}: {
+	marketplaceConfig: MarketplaceConfig;
+	sdkConfig: SdkConfig;
+	walletType: MarketplaceWallet;
+}): CreateConnectorFn[] {
+	const connectors = commonConnectors(marketplaceConfig, sdkConfig);
+
+	if (walletType === MarketplaceWallet.UNIVERSAL) {
+		connectors.push(...getUniversalWalletConfigs(sdkConfig, marketplaceConfig));
+	} else if (walletType === MarketplaceWallet.EMBEDDED) {
+		connectors.push(...getWaasConnectors(sdkConfig, marketplaceConfig));
+	} else if (walletType === MarketplaceWallet.ECOSYSTEM) {
+		connectors.push(getEcosystemConnector(marketplaceConfig, sdkConfig));
+	} else {
+		throw new Error('Invalid wallet type');
+	}
+
+	return getConnectWallets(sdkConfig.projectAccessKey, connectors);
+}
+
+function commonConnectors(
+	marketplaceConfig: MarketplaceConfig,
+	sdkConfig: SdkConfig,
+) {
+	const wallets = [];
+	const { title: appName } = marketplaceConfig;
+	const walletOptions = marketplaceConfig.walletOptions;
+	const walletConnectProjectId = sdkConfig.walletConnectProjectId;
+
+	if (walletOptions.connectors.includes('coinbase')) {
+		wallets.push(
+			coinbaseWallet({
+				appName,
+			}),
+		);
+	}
+
+	if (
+		walletConnectProjectId &&
+		walletOptions.connectors.includes('walletconnect')
+	) {
+		wallets.push(
+			walletConnect({
+				projectId: walletConnectProjectId,
+			}),
+		);
+	}
+
+	return wallets;
+}
+
+function getUniversalWalletConfigs(
+	config: SdkConfig,
+	marketplaceConfig: MarketplaceConfig,
+): Wallet[] {
+	const { projectAccessKey } = config;
+	const sequenceWalletEnv = config._internal?.sequenceWalletEnv || 'production';
+
+	const sequenceWalletOptions = {
+		walletAppURL: getSequenceWalletURL(sequenceWalletEnv),
+		defaultNetwork: DEFAULT_NETWORK,
+		connect: {
+			projectAccessKey,
+			app: marketplaceConfig.title,
+			settings: {
+				bannerUrl: marketplaceConfig.ogImage,
+			},
+		},
+	} satisfies SequenceOptions;
+
+	return [
+		sequence(sequenceWalletOptions),
+		email(sequenceWalletOptions),
+		facebook(sequenceWalletOptions),
+		google(sequenceWalletOptions),
+		apple(sequenceWalletOptions),
+		twitch(sequenceWalletOptions),
+	] as const;
+}
+
+export function getWaasConnectors(
+	config: SdkConfig,
+	marketplaceConfig: MarketplaceConfig,
+): Wallet[] {
+	const { projectAccessKey } = config;
+
+	const waasConfigKey = marketplaceConfig.walletOptions.waas?.tenantKey;
+
+	if (!waasConfigKey)
+		throw new MissingConfigError(
+			'Embedded wallet config is missing, please check your access key',
+		);
+
+	const waasOptions = marketplaceConfig.walletOptions.oidcIssuers;
+	const googleClientId = waasOptions.google;
+	const appleClientId = waasOptions.apple;
+	const appleRedirectURI = globalThis.window
+		? `https://${globalThis.window?.location?.origin}${globalThis.window?.location?.pathname}`
+		: undefined;
+
+	const wallets: Wallet[] = [];
+
+	if (marketplaceConfig.walletOptions.waas?.emailEnabled) {
+		wallets.push(
+			emailWaas({
+				projectAccessKey,
+				waasConfigKey,
+			}),
+		);
+	}
+
+	if (googleClientId) {
+		wallets.push(
+			googleWaas({
+				projectAccessKey,
+				googleClientId,
+				waasConfigKey,
+				network: DEFAULT_NETWORK,
+			}),
+		);
+	}
+
+	if (appleClientId) {
+		wallets.push(
+			appleWaas({
+				projectAccessKey,
+				appleClientId,
+				appleRedirectURI,
+				waasConfigKey,
+				network: DEFAULT_NETWORK,
+			}),
+		);
+	}
+
+	return wallets;
+}
+
+export function getEcosystemConnector(
+	marketplaceConfig: MarketplaceConfig,
+	sdkConfig: SdkConfig,
+): Wallet {
+	const ecosystemOptions = marketplaceConfig.walletOptions.ecosystem;
+	if (!ecosystemOptions) throw new MissingConfigError('ecosystem');
+	const { walletAppName, walletUrl, logoDarkUrl, logoLightUrl } =
+		ecosystemOptions;
+
+	return ecosystemWallet({
+		projectAccessKey: sdkConfig.projectAccessKey,
+		walletUrl,
+		name: walletAppName,
+		defaultNetwork: DEFAULT_NETWORK,
+		logoDark: getEcosystemLogo(logoDarkUrl, walletAppName),
+		logoLight: getEcosystemLogo(logoLightUrl, walletAppName),
+	});
+}
+
+function getEcosystemLogo(
+	url: string | undefined,
+	name: string,
+): FunctionComponent {
+	if (!url) return () => null;
+	const Logo = () =>
+		React.createElement('img', { src: url, alt: name, width: 32, height: 32 });
+	Logo.displayName = 'EcosystemLogo';
+	return Logo;
+}
+
+function getSequenceWalletURL(env: Env) {
+	switch (env) {
+		case 'development':
+			return 'https://dev.sequence.app';
+		case 'production':
+			return 'https://sequence.app';
+		case 'next':
+			return 'https://next.sequence.app';
+	}
+}

package/src/react/_internal/wagmi/index.ts

@@ -0,0 +1,2 @@
+export * from './create-config';
+export * from './get-connectors';

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

@@ -0,0 +1,416 @@
+import { ResourceStatus } from '@0xsequence/metadata';
+import { server } from '@test';
+import {
+	type Account,
+	type Address,
+	BaseError,
+	type Chain,
+	type PublicClient,
+	UserRejectedRequestError as ViemUserRejectedRequestError,
+	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 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',
+						source: '',
+						symbol: '',
+						logoURI: '',
+						deployed: false,
+						bytecodeHash: '',
+						extensions: {
+							link: '',
+							description: '',
+							categories: [],
+							ogImage: '',
+							ogName: '',
+							originChainId: 0,
+							originAddress: '',
+							blacklist: false,
+							verified: false,
+							verifiedBy: '',
+							featured: false,
+							featureIndex: 0,
+						},
+						updatedAt: '',
+						status: ResourceStatus.NOT_AVAILABLE,
+					},
+				}),
+			);
+
+			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);
+		});
+
+		it('should throw UserRejectedRequestError when user rejects signature', async () => {
+			const error = new TransactionSignatureError(
+				StepType.signEIP191,
+				new ViemUserRejectedRequestError(
+					new BaseError('User rejected request', {
+						cause: new Error('User rejected request'),
+					}),
+				),
+			);
+			vi.mocked(mockWalletClient.signMessage).mockRejectedValueOnce(error);
+			await expect(
+				walletInstance.handleSignMessageStep(mockSignatureStep),
+			).rejects.toThrow(UserRejectedRequestError);
+		});
+	});
+
+	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 throw UserRejectedRequestError when user rejects transaction', async () => {
+			const error = new TransactionExecutionError(
+				StepType.buy,
+				new ViemUserRejectedRequestError(
+					new BaseError('User rejected request'),
+				),
+			);
+			vi.mocked(mockWalletClient.sendTransaction).mockRejectedValueOnce(error);
+			await expect(
+				walletInstance.handleSendTransactionStep(1, mockTxStep),
+			).rejects.toThrow(UserRejectedRequestError);
+		});
+
+		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',
+						source: '',
+						symbol: '',
+						logoURI: '',
+						deployed: false,
+						bytecodeHash: '',
+						extensions: {
+							link: '',
+							description: '',
+							categories: [],
+							ogImage: '',
+							ogName: '',
+							originChainId: 0,
+							originAddress: '',
+							blacklist: false,
+							verified: false,
+							verifiedBy: '',
+							featured: false,
+							featureIndex: 0,
+						},
+						updatedAt: '',
+						status: ResourceStatus.AVAILABLE,
+					},
+				}),
+			);
+
+			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

@@ -0,0 +1,52 @@
+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;
+	isLoading: boolean;
+	isError: boolean;
+};
+
+export const useWallet = (): UseWalletReturn => {
+	const { chains } = useSwitchChain();
+	const {
+		data: walletClient,
+		isLoading: wagmiWalletIsLoading,
+		isError: wagmiWalletIsError,
+	} = useWalletClient();
+	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:
+			walletClient && connector && isConnected && publicClient
+				? () => {
+						return wallet({
+							wallet: walletClient,
+							chains,
+							connector,
+							sdkConfig,
+							publicClient,
+						});
+					}
+				: skipToken,
+		staleTime: Number.POSITIVE_INFINITY,
+	});
+
+	return {
+		wallet: data,
+		isLoading: isLoading || isConnecting || wagmiWalletIsLoading,
+		isError: isError || wagmiWalletIsError,
+	};
+};