@0xsequence/marketplace-sdk 0.8.7 → 0.8.8

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

@@ -17,13 +17,10 @@ import {
 } from '@0xsequence/connect';
 import React, { type FunctionComponent } from 'react';
 import type { CreateConnectorFn } from 'wagmi';
-import {
-	type Env,
-	type MarketplaceConfig,
-	MarketplaceWallet,
-	type SdkConfig,
-} from '../../../types';
+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({
@@ -40,7 +37,7 @@ export function getConnectors({
 	if (walletType === MarketplaceWallet.UNIVERSAL) {
 		connectors.push(...getUniversalWalletConfigs(sdkConfig, marketplaceConfig));
 	} else if (walletType === MarketplaceWallet.EMBEDDED) {
-		connectors.push(...getWaasConnectors(sdkConfig));
+		connectors.push(...getWaasConnectors(sdkConfig, marketplaceConfig));
 	} else if (walletType === MarketplaceWallet.ECOSYSTEM) {
 		connectors.push(getEcosystemConnector(marketplaceConfig, sdkConfig));
 	} else {
@@ -57,7 +54,7 @@ function commonConnectors(
 	const wallets = [];
 	const { title: appName } = marketplaceConfig;
 	const walletOptions = marketplaceConfig.walletOptions;
-	const walletConnectProjectId = sdkConfig.wallet?.walletConnectProjectId;
+	const walletConnectProjectId = sdkConfig.walletConnectProjectId;
 
 	if (walletOptions.connectors.includes('coinbase')) {
 		wallets.push(
@@ -110,23 +107,36 @@ function getUniversalWalletConfigs(
 	] as const;
 }
 
-export function getWaasConnectors(sdkConfig: SdkConfig): Wallet[] {
-	const { projectAccessKey } = sdkConfig;
+export function getWaasConnectors(
+	config: SdkConfig,
+	marketplaceConfig: MarketplaceConfig,
+): Wallet[] {
+	const { projectAccessKey } = config;
 
-	const waasConfigKey = sdkConfig.wallet?.embedded?.waasConfigKey;
+	const waasConfigKey = marketplaceConfig.walletOptions.waas?.tenantKey;
 
-	if (!waasConfigKey) throw new MissingConfigError('waasConfigKey');
+	if (!waasConfigKey)
+		throw new MissingConfigError(
+			'Embedded wallet config is missing, please check your access key',
+		);
 
-	const { googleClientId, appleClientId, appleRedirectURI } =
-		sdkConfig.wallet?.embedded || {};
+	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[] = [
-		emailWaas({
-			projectAccessKey,
-			waasConfigKey,
-			network: DEFAULT_NETWORK,
-		}),
-	];
+	const wallets: Wallet[] = [];
+
+	if (marketplaceConfig.walletOptions.waas?.emailEnabled) {
+		wallets.push(
+			emailWaas({
+				projectAccessKey,
+				waasConfigKey,
+			}),
+		);
+	}
 
 	if (googleClientId) {
 		wallets.push(

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

@@ -3,8 +3,10 @@ import { server } from '@test';
 import {
 	type Account,
 	type Address,
+	BaseError,
 	type Chain,
 	type PublicClient,
+	UserRejectedRequestError as ViemUserRejectedRequestError,
 	type WalletClient,
 	hexToBigInt,
 } from 'viem';
@@ -264,6 +266,21 @@ describe('wallet', () => {
 				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', () => {
@@ -315,6 +332,19 @@ describe('wallet', () => {
 			).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,

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

@@ -2,11 +2,13 @@ import type { TransactionReceipt } from '@0xsequence/indexer';
 import {
 	type Account,
 	type Address,
+	BaseError,
 	type Chain,
 	type Hex,
 	type PublicClient,
 	TransactionReceiptNotFoundError,
 	type TypedDataDomain,
+	UserRejectedRequestError as ViemUserRejectedRequestError,
 	type WalletClient as ViemWalletClient,
 	WaitForTransactionReceiptTimeoutError,
 	custom,
@@ -59,6 +61,7 @@ export interface WalletInstance {
 		contractAddress: Address;
 		spender: Address | 'sequenceMarketV1' | 'sequenceMarketV2';
 	}) => Promise<bigint | boolean>;
+	publicClient: PublicClient;
 }
 
 const isSequenceWallet = (connector: Connector) =>
@@ -147,8 +150,17 @@ export const wallet = ({
 						message: stepItem.signature!.value,
 					});
 				}
-			} catch (error) {
+			} 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);
 			}
 		},
@@ -180,8 +192,17 @@ export const wallet = ({
 						gas: hexToBigInt(stepItem.gas),
 					}),
 				});
-			} catch (error) {
+			} 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);
 			}
 		},
@@ -197,6 +218,7 @@ export const wallet = ({
 				return receipt;
 			} catch (error) {
 				logger.error('Transaction confirmation failed', error);
+
 				throw new TransactionConfirmationError(txHash, error as Error);
 			}
 		},
@@ -243,6 +265,7 @@ export const wallet = ({
 					throw new Error('Unsupported contract type for approval checking');
 			}
 		},
+		publicClient,
 	};
 
 	return walletInstance;

package/src/react/hooks/__tests__/__snapshots__/useMarketplaceConfig.test.tsx.snap

@@ -0,0 +1,96 @@
+// Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
+
+exports[`useMarketplaceConfig > should fetch marketplace config and styles successfully 1`] = `
+{
+  "bannerUrl": "",
+  "collections": [
+    {
+      "address": "0x0000000000000000000000000000000000000000",
+      "bannerUrl": "",
+      "chainId": 1,
+      "currencyOptions": [
+        "0x0000000000000000000000000000000000000000",
+        "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
+      ],
+      "destinationMarketplace": "sequence_marketplace_v2",
+      "exchanges": [],
+      "feePercentage": 3.5,
+      "filterSettings": {
+        "exclusions": [
+          {
+            "condition": "SPECIFIC_VALUE",
+            "key": "Type",
+            "value": "Sample",
+          },
+        ],
+        "filterOrder": [
+          "Type",
+          "Rarity",
+        ],
+      },
+      "marketplaceType": "ORDERBOOK",
+    },
+    {
+      "address": "0x1234567890123456789012345678901234567890",
+      "bannerUrl": "https://example.com/collection-banner.png",
+      "chainId": 137,
+      "currencyOptions": [
+        "0x0000000000000000000000000000000000000000",
+      ],
+      "destinationMarketplace": "opensea",
+      "exchanges": [],
+      "feePercentage": 2.5,
+      "filterSettings": {
+        "exclusions": [
+          {
+            "condition": "ENTIRE_KEY",
+            "key": "Category",
+          },
+          {
+            "condition": "SPECIFIC_VALUE",
+            "key": "Level",
+            "value": "Legendary",
+          },
+        ],
+        "filterOrder": [
+          "Category",
+          "Level",
+          "Element",
+        ],
+      },
+      "marketplaceType": "ORDERBOOK",
+    },
+  ],
+  "cssString": "
+  .marketplace-theme {
+    --primary-color: #000000;
+  }
+",
+  "faviconUrl": "https://example.com/favicon.png",
+  "landingBannerUrl": "https://example.com/banner.png",
+  "landingPageLayout": "default",
+  "logoUrl": "https://example.com/logo.png",
+  "manifestUrl": "https://api.sequence.build/marketplace//manifest.json",
+  "projectId": 1,
+  "publisherId": "test-publisher",
+  "shortDescription": "A test marketplace",
+  "socials": {
+    "discord": "https://discord.com/test",
+    "instagram": "https://instagram.com/test",
+    "tiktok": "",
+    "twitter": "https://twitter.com/test",
+    "website": "",
+    "youtube": "",
+  },
+  "title": "Test Marketplace",
+  "walletOptions": {
+    "connectors": [
+      "coinbase",
+      "walletconnect",
+    ],
+    "includeEIP6963Wallets": true,
+    "oidcIssuers": {},
+    "walletType": "UNIVERSAL",
+  },
+}
+`;

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

@@ -3,7 +3,7 @@ import { http, HttpResponse } from 'msw';
 import { zeroAddress } from 'viem';
 import { describe, expect, it } from 'vitest';
 import {
-	mockContractInfo,
+	mockEthCollection,
 	mockMetadataEndpoint,
 } from '../../_internal/api/__mocks__/metadata.msw';
 import type { UseCollectionArgs } from '../useCollection';
@@ -11,9 +11,8 @@ import { useCollection } from '../useCollection';
 
 describe('useCollection', () => {
 	const defaultArgs: UseCollectionArgs = {
-		chainId: 1,
-		collectionAddress: zeroAddress,
-		query: {},
+		chainId: mockEthCollection.chainId,
+		collectionAddress: mockEthCollection.address,
 	};
 
 	it('should fetch collection data successfully', async () => {
@@ -29,7 +28,7 @@ describe('useCollection', () => {
 		});
 
 		// Verify the data matches our mock
-		expect(result.current.data).toEqual(mockContractInfo);
+		expect(result.current.data).toEqual(mockEthCollection);
 		expect(result.current.error).toBeNull();
 	});
 

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

@@ -2,11 +2,11 @@ import { renderHook, server, waitFor } from '@test';
 import { USDC_ADDRESS } from '@test/const';
 import { http, HttpResponse } from 'msw';
 import { describe, expect, it } from 'vitest';
+import { mockConfig } from '../../_internal/api/__mocks__/builder.msw';
 import {
 	mockCurrencies,
 	mockMarketplaceEndpoint,
 } from '../../_internal/api/__mocks__/marketplace.msw';
-import { mockConfig } from '../options/__mocks__/marketplaceConfig.msw';
 import { useCurrencies } from '../useCurrencies';
 
 describe('useCurrencies', () => {

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

@@ -2,6 +2,10 @@ import { renderHook, server, waitFor } from '@test';
 import { http, HttpResponse } from 'msw';
 import { zeroAddress } from 'viem';
 import { beforeEach, describe, expect, it } from 'vitest';
+import {
+	createLookupMarketplaceConfigHandler,
+	mockConfig,
+} from '../../_internal/api/__mocks__/builder.msw';
 import {
 	mockIndexerEndpoint,
 	mockTokenBalance,
@@ -11,7 +15,6 @@ import {
 	mockMarketplaceEndpoint,
 } from '../../_internal/api/__mocks__/marketplace.msw';
 import type { UseInventoryArgs } from '../../queries/inventory';
-import { mockConfig } from '../options/__mocks__/marketplaceConfig.msw';
 import { useInventory } from '../useInventory';
 
 // Make sure mockCollectibleOrder has a tokenId of "1" for tests
@@ -128,21 +131,17 @@ describe('useInventory', () => {
 	it('should use isLaos721 flag from marketplaceConfig', async () => {
 		// Setup config with LAOS collection
 		const laosCollectionAddress = '0x1234567890123456789012345678901234567890';
-		server.use(
-			http.get('*/marketplace/*/settings.json', () => {
-				const configWithLaos = {
-					...mockConfig,
-					collections: [
-						{
-							...mockConfig.collections[0],
-							address: laosCollectionAddress,
-							isLAOSERC721: true,
-						},
-					],
-				};
-				return HttpResponse.json(configWithLaos);
-			}),
-		);
+		const configWithLaos = {
+			...mockConfig,
+			collections: [
+				{
+					...mockConfig.collections[0],
+					address: laosCollectionAddress,
+					isLAOSERC721: true,
+				},
+			],
+		};
+		server.use(createLookupMarketplaceConfigHandler(configWithLaos));
 
 		const laosArgs: UseInventoryArgs = {
 			...defaultArgs,

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

@@ -1,51 +1,20 @@
-import { ResourceStatus } from '@0xsequence/metadata';
 import { renderHook, server, waitFor } from '@test';
 import { http, HttpResponse } from 'msw';
 import { describe, expect, it } from 'vitest';
 import { MarketplaceType, OrderbookKind } from '../../../types';
-import { mockContractInfo } from '../../_internal/api/__mocks__/metadata.msw';
 import {
-	createConfigHandler,
+	createLookupMarketplaceConfigHandler,
 	mockConfig,
-} from '../options/__mocks__/marketplaceConfig.msw';
+} from '../../_internal/api/__mocks__/builder.msw';
+import {
+	mockEthCollection,
+	mockPolCollection,
+} from '../../_internal/api/__mocks__/metadata.msw';
 import { useListCollections } from '../useListCollections';
 
 describe('useListCollections', () => {
-	const defaultArgs = {
-		query: {
-			enabled: true,
-		},
-	};
-
 	it('should fetch collections successfully', async () => {
-		// Mock marketplace config with collection
-		server.use(
-			createConfigHandler({
-				...mockConfig,
-				collections: [
-					{
-						chainId: 1,
-						address:
-							'0x1234567890123456789012345678901234567890' as `0x${string}`,
-						feePercentage: 2.5,
-						marketplaceType: MarketplaceType.ORDERBOOK,
-						currencyOptions: [],
-						exchanges: [],
-						bannerUrl: '',
-						destinationMarketplace: OrderbookKind.sequence_marketplace_v2,
-					},
-				],
-			}),
-			http.post('*/rpc/Metadata/GetContractInfoBatch', () => {
-				return HttpResponse.json({
-					contractInfoMap: {
-						'0x1234567890123456789012345678901234567890': mockContractInfo,
-					},
-				});
-			}),
-		);
-
-		const { result } = renderHook(() => useListCollections(defaultArgs));
+		const { result } = renderHook(() => useListCollections());
 
 		// Wait for data to be loaded
 		await waitFor(() => {
@@ -53,20 +22,20 @@ describe('useListCollections', () => {
 		});
 
 		// Verify the data matches our mock
-		expect(result.current.data).toEqual([mockContractInfo]);
+		expect(result.current.data).toEqual([mockEthCollection, mockPolCollection]);
 		expect(result.current.error).toBeNull();
 	});
 
 	it('should handle empty collections', async () => {
 		// Mock marketplace config with empty collections
 		server.use(
-			createConfigHandler({
+			createLookupMarketplaceConfigHandler({
 				...mockConfig,
 				collections: [],
 			}),
 		);
 
-		const { result } = renderHook(() => useListCollections(defaultArgs));
+		const { result } = renderHook(() => useListCollections());
 
 		await waitFor(() => {
 			expect(result.current.data).toBeDefined();
@@ -79,7 +48,7 @@ describe('useListCollections', () => {
 	it('should handle error states', async () => {
 		// Mock marketplace config with collection
 		server.use(
-			createConfigHandler({
+			createLookupMarketplaceConfigHandler({
 				...mockConfig,
 				collections: [
 					{
@@ -103,7 +72,7 @@ describe('useListCollections', () => {
 			}),
 		);
 
-		const { result } = renderHook(() => useListCollections(defaultArgs));
+		const { result } = renderHook(() => useListCollections());
 
 		await waitFor(() => {
 			expect(result.current.isError).toBe(true);
@@ -118,7 +87,7 @@ describe('useListCollections', () => {
 
 		// Mock marketplace config with collection
 		server.use(
-			createConfigHandler({
+			createLookupMarketplaceConfigHandler({
 				...mockConfig,
 				collections: [
 					{
@@ -138,7 +107,7 @@ describe('useListCollections', () => {
 				requestMade = true;
 				return HttpResponse.json({
 					contractInfoMap: {
-						'0x1234567890123456789012345678901234567890': mockContractInfo,
+						'0x1234567890123456789012345678901234567890': mockEthCollection,
 					},
 				});
 			}),
@@ -160,128 +129,14 @@ describe('useListCollections', () => {
 	});
 
 	it('should handle multiple collections from different chains', async () => {
-		const mockContractInfo2 = {
-			...mockContractInfo,
-			address: '0x1234567890123456789012345678901234567890' as `0x${string}`,
-			chainId: 137, // Different chain (Polygon)
-		};
-
-		// Mock marketplace config with multiple collections
-		server.use(
-			createConfigHandler({
-				...mockConfig,
-				collections: [
-					{
-						chainId: 1,
-						address:
-							'0x1234567890123456789012345678901234567890' as `0x${string}`,
-						feePercentage: 2.5,
-						marketplaceType: MarketplaceType.ORDERBOOK,
-						currencyOptions: [],
-						exchanges: [],
-						bannerUrl: '',
-						destinationMarketplace: OrderbookKind.sequence_marketplace_v2,
-					},
-					{
-						chainId: 137,
-						address: mockContractInfo2.address,
-						feePercentage: 2.5,
-						marketplaceType: MarketplaceType.ORDERBOOK,
-						currencyOptions: [],
-						exchanges: [],
-						bannerUrl: '',
-						destinationMarketplace: OrderbookKind.sequence_marketplace_v2,
-					},
-				],
-			}),
-			http.post('*/rpc/Metadata/GetContractInfoBatch', async ({ request }) => {
-				const body = (await request.json()) as { chainID: string };
-				if (body.chainID === '1') {
-					return HttpResponse.json({
-						contractInfoMap: {
-							'0x1234567890123456789012345678901234567890': mockContractInfo,
-						},
-					});
-				}
-				return HttpResponse.json({
-					contractInfoMap: {
-						[mockContractInfo2.address]: mockContractInfo2,
-					},
-				});
-			}),
-		);
-
-		const { result } = renderHook(() => useListCollections(defaultArgs));
+		// TODO: This test should be more robust, make sure we validate that the marketplace config has multiple chains
+		// then the to equal should just check that we are fetching the data from those
+		const { result } = renderHook(() => useListCollections());
 
 		await waitFor(() => {
 			expect(result.current.data).toBeDefined();
 		});
 
-		expect(result.current.data).toHaveLength(2);
-		expect(result.current.data).toEqual(
-			expect.arrayContaining([mockContractInfo, mockContractInfo2]),
-		);
-	});
-
-	it('should handle collections with different resource statuses', async () => {
-		const mockUnavailableContract = {
-			...mockContractInfo,
-			address: '0x9876543210987654321098765432109876543210' as `0x${string}`,
-			status: ResourceStatus.NOT_AVAILABLE,
-		};
-
-		// Mock marketplace config with multiple collections
-		server.use(
-			createConfigHandler({
-				...mockConfig,
-				collections: [
-					{
-						chainId: 1,
-						address:
-							'0x1234567890123456789012345678901234567890' as `0x${string}`,
-						feePercentage: 2.5,
-						marketplaceType: MarketplaceType.ORDERBOOK,
-						currencyOptions: [],
-						exchanges: [],
-						bannerUrl: '',
-						destinationMarketplace: OrderbookKind.sequence_marketplace_v2,
-					},
-					{
-						chainId: 1,
-						address: mockUnavailableContract.address,
-						feePercentage: 2.5,
-						marketplaceType: MarketplaceType.ORDERBOOK,
-						currencyOptions: [],
-						exchanges: [],
-						bannerUrl: '',
-						destinationMarketplace: OrderbookKind.sequence_marketplace_v2,
-					},
-				],
-			}),
-		);
-
-		// Mock metadata response for both contracts
-		server.use(
-			http.post('*/rpc/Metadata/GetContractInfoBatch', () => {
-				return HttpResponse.json({
-					contractInfoMap: {
-						'0x1234567890123456789012345678901234567890': mockContractInfo,
-						'0x9876543210987654321098765432109876543210':
-							mockUnavailableContract,
-					},
-				});
-			}),
-		);
-
-		const { result } = renderHook(() => useListCollections(defaultArgs));
-
-		await waitFor(() => {
-			expect(result.current.data).toBeDefined();
-		});
-
-		expect(result.current.data).toHaveLength(2);
-		expect(result.current.data).toEqual(
-			expect.arrayContaining([mockContractInfo, mockUnavailableContract]),
-		);
+		expect(result.current.data).toEqual([mockEthCollection, mockPolCollection]);
 	});
 });