@0xsequence/marketplace-sdk 0.8.3 → 0.8.5

package/src/react/_internal/wagmi/__tests__/create-config.test.ts

@@ -174,16 +174,6 @@ describe('createWagmiConfig', () => {
 
 	describe('failure cases', () => {
 		it('should throw error when trying to use embedded wallet without waasConfigKey', () => {
-			const marketplaceConfig: MarketplaceConfig = {
-				...baseMarketplaceConfig,
-				walletOptions: {
-					connectors: ['walletconnect'],
-					includeEIP6963Wallets: false,
-					walletType: MarketplaceWallet.EMBEDDED,
-					oidcIssuers: {},
-				},
-			};
-
 			const sdkConfig: SdkConfig = {
 				...baseSdkConfig,
 				wallet: {
@@ -197,7 +187,7 @@ describe('createWagmiConfig', () => {
 			};
 
 			expect(() =>
-				getWaasConnectors(marketplaceConfig, {
+				getWaasConnectors({
 					...sdkConfig,
 					wallet: {
 						...sdkConfig.wallet,

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

@@ -39,8 +39,12 @@ export function getConnectors({
 
 	if (walletType === MarketplaceWallet.UNIVERSAL) {
 		connectors.push(...getUniversalWalletConfigs(sdkConfig, marketplaceConfig));
+	} else if (walletType === MarketplaceWallet.EMBEDDED) {
+		connectors.push(...getWaasConnectors(sdkConfig));
+	} else if (walletType === MarketplaceWallet.ECOSYSTEM) {
+		connectors.push(getEcosystemConnector(marketplaceConfig, sdkConfig));
 	} else {
-		connectors.push(...getWaasConnectors(marketplaceConfig, sdkConfig));
+		throw new Error('Invalid wallet type');
 	}
 
 	return getConnectWallets(sdkConfig.projectAccessKey, connectors);
@@ -106,10 +110,7 @@ function getUniversalWalletConfigs(
 	] as const;
 }
 
-export function getWaasConnectors(
-	marketplaceConfig: MarketplaceConfig,
-	sdkConfig: SdkConfig,
-): Wallet[] {
+export function getWaasConnectors(sdkConfig: SdkConfig): Wallet[] {
 	const { projectAccessKey } = sdkConfig;
 
 	const waasConfigKey = sdkConfig.wallet?.embedded?.waasConfigKey;
@@ -150,33 +151,35 @@ export function getWaasConnectors(
 		);
 	}
 
-	const walletType = marketplaceConfig.walletOptions.walletType;
-	if (walletType === MarketplaceWallet.ECOSYSTEM) {
-		const ecosystemOptions = marketplaceConfig.walletOptions.ecosystem;
-		if (!ecosystemOptions) throw new MissingConfigError('ecosystem');
-		const { walletAppName, walletUrl, logoDarkUrl, logoLightUrl } =
-			ecosystemOptions;
-		wallets.push(
-			ecosystemWallet({
-				projectAccessKey: sdkConfig.projectAccessKey,
-				walletUrl,
-				name: walletAppName,
-				defaultNetwork: DEFAULT_NETWORK,
-				logoDark: getEcosystemLogo(logoDarkUrl, walletAppName),
-				logoLight: getEcosystemLogo(logoLightUrl, walletAppName),
-			}),
-		);
-	}
-
 	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 });
+	const Logo = () =>
+		React.createElement('img', { src: url, alt: name, width: 32, height: 32 });
 	Logo.displayName = 'EcosystemLogo';
 	return Logo;
 }

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

@@ -12,8 +12,9 @@ import {
 	WalletInstanceNotFoundError,
 } from '../../../utils/_internal/error/transaction';
 import {
+	createMockStep,
+	createMockSteps,
 	mockMarketplaceEndpoint,
-	mockSteps,
 } from '../../_internal/api/__mocks__/marketplace.msw';
 import { MarketplaceKind, StepType } from '../../_internal/api/marketplace.gen';
 import { useWallet } from '../../_internal/wallet/useWallet';
@@ -66,12 +67,7 @@ describe('useCancelTransactionSteps', () => {
 		server.use(
 			http.post(mockMarketplaceEndpoint('GenerateCancelTransaction'), () => {
 				return HttpResponse.json({
-					steps: [
-						{
-							...mockSteps[0],
-							id: StepType.cancel,
-						},
-					],
+					steps: createMockSteps([StepType.cancel]),
 				});
 			}),
 		);
@@ -106,8 +102,7 @@ describe('useCancelTransactionSteps', () => {
 				return HttpResponse.json({
 					steps: [
 						{
-							...mockSteps[0],
-							id: StepType.signEIP712,
+							...createMockStep(StepType.signEIP712),
 						},
 					],
 				});

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

@@ -3,10 +3,11 @@ import { http, HttpResponse } from 'msw';
 import { zeroAddress } from 'viem';
 import { describe, expect, it, vi } from 'vitest';
 import {
+	createMockStep,
+	createMockSteps,
 	mockMarketplaceEndpoint,
-	mockSteps,
 } from '../../_internal/api/__mocks__/marketplace.msw';
-import { MarketplaceKind } from '../../_internal/api/marketplace.gen';
+import { MarketplaceKind, StepType } from '../../_internal/api/marketplace.gen';
 import { useGenerateCancelTransaction } from '../useGenerateCancelTransaction';
 
 const defaultArgs = {
@@ -28,7 +29,7 @@ describe('useGenerateCancelTransaction', () => {
 		});
 
 		await waitFor(() => {
-			expect(result.current.data).toEqual(mockSteps);
+			expect(result.current.data).toEqual(createMockSteps([StepType.cancel]));
 		});
 		expect(result.current.error).toBeNull();
 	});
@@ -123,7 +124,7 @@ describe('useGenerateCancelTransaction', () => {
 
 		await waitFor(() => {
 			expect(onSuccess).toHaveBeenCalledWith(
-				[mockSteps[0]],
+				[createMockStep(StepType.cancel)],
 				defaultArgs,
 				undefined,
 			);

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

@@ -51,11 +51,13 @@ describe('useGenerateListingTransaction', () => {
 			    {
 			      "data": "0x...",
 			      "id": "tokenApproval",
-			      "post": {
-			        "body": {},
-			        "endpoint": "/api/order",
-			        "method": "POST",
-			      },
+			      "price": "0",
+			      "to": "0x1234567890123456789012345678901234567890",
+			      "value": "0",
+			    },
+			    {
+			      "data": "0x...",
+			      "id": "createListing",
 			      "price": "0",
 			      "to": "0x1234567890123456789012345678901234567890",
 			      "value": "0",
@@ -96,11 +98,13 @@ describe('useGenerateListingTransaction', () => {
 			    {
 			      "data": "0x...",
 			      "id": "tokenApproval",
-			      "post": {
-			        "body": {},
-			        "endpoint": "/api/order",
-			        "method": "POST",
-			      },
+			      "price": "0",
+			      "to": "0x1234567890123456789012345678901234567890",
+			      "value": "0",
+			    },
+			    {
+			      "data": "0x...",
+			      "id": "createListing",
 			      "price": "0",
 			      "to": "0x1234567890123456789012345678901234567890",
 			      "value": "0",

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

@@ -1,12 +1,19 @@
 import { renderHook, server, waitFor } from '@test';
+import { createMockWallet } from '@test/mocks/wallet';
 import { http, HttpResponse } from 'msw';
 import { zeroAddress } from 'viem';
 import { beforeEach, describe, expect, it, vi } from 'vitest';
-import { mockMarketplaceEndpoint } from '../../_internal/api/__mocks__/marketplace.msw';
+import {
+	createMockSteps,
+	mockMarketplaceEndpoint,
+} from '../../_internal/api/__mocks__/marketplace.msw';
 import {
 	ContractType,
 	OrderbookKind,
+	StepType,
+	WalletKind,
 } from '../../_internal/api/marketplace.gen';
+import * as walletModule from '../../_internal/wallet/useWallet';
 import { useGenerateOfferTransaction } from '../useGenerateOfferTransaction';
 
 describe('useGenerateOfferTransaction', () => {
@@ -44,38 +51,9 @@ describe('useGenerateOfferTransaction', () => {
 
 		await result.current.generateOfferTransactionAsync(mockTransactionProps);
 
-		expect(mockOnSuccess.mock.lastCall).toMatchInlineSnapshot(`
-			[
-			  [
-			    {
-			      "data": "0x...",
-			      "id": "tokenApproval",
-			      "post": {
-			        "body": {},
-			        "endpoint": "/api/order",
-			        "method": "POST",
-			      },
-			      "price": "0",
-			      "to": "0x1234567890123456789012345678901234567890",
-			      "value": "0",
-			    },
-			  ],
-			  {
-			    "collectionAddress": "0x0000000000000000000000000000000000000000",
-			    "contractType": "ERC721",
-			    "maker": "0x0000000000000000000000000000000000000000",
-			    "offer": {
-			      "currencyAddress": "0x0000000000000000000000000000000000000000",
-			      "expiry": 2024-12-31T00:00:00.000Z,
-			      "pricePerToken": "1000000000000000000",
-			      "quantity": "1",
-			      "tokenId": "1",
-			    },
-			    "orderbook": "sequence_marketplace_v2",
-			  },
-			  undefined,
-			]
-		`);
+		expect(mockOnSuccess).toHaveBeenCalled();
+		const steps = mockOnSuccess.mock.calls[0]?.[0];
+		expect(steps.length).toBeGreaterThan(0);
 	});
 
 	it('should handle non-async generation with callback', async () => {
@@ -88,38 +66,9 @@ describe('useGenerateOfferTransaction', () => {
 		await waitFor(() => {
 			expect(mockOnSuccess).toHaveBeenCalled();
 		});
-		expect(mockOnSuccess.mock.lastCall).toMatchInlineSnapshot(`
-			[
-			  [
-			    {
-			      "data": "0x...",
-			      "id": "tokenApproval",
-			      "post": {
-			        "body": {},
-			        "endpoint": "/api/order",
-			        "method": "POST",
-			      },
-			      "price": "0",
-			      "to": "0x1234567890123456789012345678901234567890",
-			      "value": "0",
-			    },
-			  ],
-			  {
-			    "collectionAddress": "0x0000000000000000000000000000000000000000",
-			    "contractType": "ERC721",
-			    "maker": "0x0000000000000000000000000000000000000000",
-			    "offer": {
-			      "currencyAddress": "0x0000000000000000000000000000000000000000",
-			      "expiry": 2024-12-31T00:00:00.000Z,
-			      "pricePerToken": "1000000000000000000",
-			      "quantity": "1",
-			      "tokenId": "1",
-			    },
-			    "orderbook": "sequence_marketplace_v2",
-			  },
-			  undefined,
-			]
-		`);
+
+		const steps = mockOnSuccess.mock.calls[0]?.[0];
+		expect(steps.length).toBeGreaterThan(0);
 	});
 
 	it('should handle API errors', async () => {
@@ -166,4 +115,105 @@ describe('useGenerateOfferTransaction', () => {
 
 		expect(mockOnSuccess).not.toHaveBeenCalled();
 	});
+
+	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
+			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;
+
+						// For Sequence wallet - only return createOffer step
+						return HttpResponse.json({
+							steps: createMockSteps([StepType.createOffer]),
+						});
+					},
+				),
+			);
+
+			const { result } = renderHook(() =>
+				useGenerateOfferTransaction(defaultArgs),
+			);
+
+			await result.current.generateOfferTransactionAsync(mockTransactionProps);
+
+			expect(mockOnSuccess).toHaveBeenCalled();
+			const steps = mockOnSuccess.mock.calls[0]?.[0];
+
+			// 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
+			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;
+
+						// For non-Sequence wallet - return tokenApproval and createOffer steps
+						return HttpResponse.json({
+							steps: createMockSteps([
+								StepType.tokenApproval,
+								StepType.createOffer,
+							]),
+						});
+					},
+				),
+			);
+
+			const { result } = renderHook(() =>
+				useGenerateOfferTransaction(defaultArgs),
+			);
+
+			await result.current.generateOfferTransactionAsync(mockTransactionProps);
+
+			expect(mockOnSuccess).toHaveBeenCalled();
+			const steps = mockOnSuccess.mock.calls[0]?.[0];
+
+			// Verify there are two steps: tokenApproval and createOffer
+			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/__tests__/useGenerateSellTransaction.test.tsx

@@ -3,13 +3,14 @@ import { http, HttpResponse } from 'msw';
 import { zeroAddress } from 'viem';
 import { beforeEach, describe, expect, it, vi } from 'vitest';
 import {
+	createMockSteps,
 	mockMarketplaceEndpoint,
-	mockSteps,
 } from '../../_internal/api/__mocks__/marketplace.msw';
 import {
 	ContractType,
 	MarketplaceKind,
 	OrderbookKind,
+	StepType,
 } from '../../_internal/api/marketplace.gen';
 import { useGenerateSellTransaction } from '../useGenerateSellTransaction';
 
@@ -53,11 +54,13 @@ describe('useGenerateSellTransaction', () => {
 			    {
 			      "data": "0x...",
 			      "id": "tokenApproval",
-			      "post": {
-			        "body": {},
-			        "endpoint": "/api/order",
-			        "method": "POST",
-			      },
+			      "price": "0",
+			      "to": "0x1234567890123456789012345678901234567890",
+			      "value": "0",
+			    },
+			    {
+			      "data": "0x...",
+			      "id": "sell",
 			      "price": "0",
 			      "to": "0x1234567890123456789012345678901234567890",
 			      "value": "0",
@@ -91,7 +94,7 @@ describe('useGenerateSellTransaction', () => {
 
 		await waitFor(() => {
 			expect(mockOnSuccess).toHaveBeenCalledWith(
-				mockSteps,
+				createMockSteps([StepType.tokenApproval, StepType.sell]),
 				mockTransactionProps,
 				undefined,
 			);