@0xsequence/marketplace-sdk 0.8.12 → 0.10.0

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

@@ -1,6 +1,4 @@
 import {
-	type SequenceOptions,
-	type Wallet,
 	apple,
 	appleWaas,
 	coinbaseWallet,
@@ -11,8 +9,10 @@ import {
 	getConnectWallets,
 	google,
 	googleWaas,
+	type SequenceOptions,
 	sequence,
 	twitch,
+	type Wallet,
 	walletConnect,
 } from '@0xsequence/connect';
 import React, { type FunctionComponent } from 'react';
@@ -82,14 +82,16 @@ function getUniversalWalletConfigs(
 	config: SdkConfig,
 	marketplaceConfig: MarketplaceConfig,
 ): Wallet[] {
-	const sequenceWalletEnv =
-		config._internal?.overrides?.api?.sequenceWallet?.env || 'production';
+	const sequenceWalletOverrides =
+		config._internal?.overrides?.api?.sequenceWallet;
+	const sequenceWalletUrl =
+		sequenceWalletOverrides?.url ||
+		getSequenceWalletURL(sequenceWalletOverrides?.env || 'production');
 	const projectAccessKey =
-		config._internal?.overrides?.api?.sequenceWallet?.accessKey ||
-		config.projectAccessKey;
+		sequenceWalletOverrides?.accessKey || config.projectAccessKey;
 
 	const sequenceWalletOptions = {
-		walletAppURL: getSequenceWalletURL(sequenceWalletEnv),
+		walletAppURL: sequenceWalletUrl,
 		defaultNetwork: DEFAULT_NETWORK,
 		connect: {
 			projectAccessKey,

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

@@ -5,10 +5,10 @@ import {
 	type Address,
 	BaseError,
 	type Chain,
+	hexToBigInt,
 	type PublicClient,
 	UserRejectedRequestError as ViemUserRejectedRequestError,
 	type WalletClient,
-	hexToBigInt,
 } from 'viem';
 import { beforeEach, describe, expect, it, vi } from 'vitest';
 import type { Connector } from 'wagmi';

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

@@ -4,18 +4,18 @@ import {
 	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,
-	custom,
-	erc20Abi,
-	erc721Abi,
-	hexToBigInt,
-	isHex,
 } from 'viem';
 import type { Connector } from 'wagmi';
 import type { SwitchChainErrorType } from 'wagmi/actions';
@@ -32,7 +32,7 @@ import {
 	TransactionSignatureError,
 	UserRejectedRequestError,
 } from '../../../utils/_internal/error/transaction';
-import { StepType, WalletKind, getIndexerClient } from '../api';
+import { getIndexerClient, StepType, WalletKind } from '../api';
 import { createLogger } from '../logger';
 import type { SignatureStep, TransactionStep } from '../utils';
 
@@ -46,7 +46,7 @@ export interface WalletInstance {
 	walletKind: WalletKind;
 	getChainId: () => Promise<number>;
 	switchChain: (chainId: number) => Promise<void>;
-	address: () => Promise<Hex>;
+	address: () => Promise<Address>;
 	handleSignMessageStep: (stepItem: SignatureStep) => Promise<Hex | undefined>;
 	handleSendTransactionStep: (
 		chainId: number,
@@ -132,21 +132,21 @@ export const wallet = ({
 						account: wallet.account,
 						message,
 					});
-					// biome-ignore lint/style/noUselessElse: <explanation>
-				} else if (stepItem.id === StepType.signEIP712) {
+				}
+				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: <explanation>
+						// 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: <explanation>
+						// biome-ignore lint/style/noNonNullAssertion: signature is guaranteed to exist for EIP712 step type
 						types: stepItem.signature!.types,
-						// biome-ignore lint/style/noNonNullAssertion: <explanation>
+						// biome-ignore lint/style/noNonNullAssertion: signature is guaranteed to exist for EIP712 step type
 						primaryType: stepItem.signature!.primaryType,
-						// biome-ignore lint/style/noNonNullAssertion: <explanation>
+						// biome-ignore lint/style/noNonNullAssertion: signature is guaranteed to exist for EIP712 step type
 						message: stepItem.signature!.value,
 					});
 				}
@@ -241,26 +241,26 @@ export const wallet = ({
 
 			switch (tokenType) {
 				case 'ERC20':
-					return await publicClient.readContract({
-						address: contractAddress as Hex,
+					return (await publicClient.readContract({
+						address: contractAddress as Address,
 						abi: erc20Abi,
 						functionName: 'allowance',
 						args: [walletAddress, spenderAddress],
-					});
+					})) as bigint;
 				case 'ERC721':
-					return await publicClient.readContract({
-						address: contractAddress as Hex,
+					return (await publicClient.readContract({
+						address: contractAddress as Address,
 						abi: erc721Abi,
 						functionName: 'isApprovedForAll',
 						args: [walletAddress, spenderAddress],
-					});
+					})) as boolean;
 				case 'ERC1155':
-					return await publicClient.readContract({
-						address: contractAddress as Hex,
+					return (await publicClient.readContract({
+						address: contractAddress as Address,
 						abi: ERC1155_ABI,
 						functionName: 'isApprovedForAll',
 						args: [walletAddress, spenderAddress],
-					});
+					})) as boolean;
 				default:
 					throw new Error('Unsupported contract type for approval checking');
 			}

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

@@ -150,6 +150,11 @@ exports[`useListCollections > should fetch collections successfully 1`] = `
     "source": "https://example.com/source",
     "status": "AVAILABLE",
     "symbol": "MOCK",
+    "tokenIds": [
+      "1",
+      "2",
+      "3",
+    ],
     "type": "ERC721",
     "updatedAt": "2025-05-01T04:39:56.936Z",
   },
@@ -187,6 +192,11 @@ exports[`useListCollections > should fetch collections successfully 1`] = `
     "source": "https://example.com/source",
     "status": "AVAILABLE",
     "symbol": "MOCK",
+    "tokenIds": [
+      "4",
+      "5",
+      "6",
+    ],
     "type": "ERC721",
     "updatedAt": "2025-05-01T04:39:56.936Z",
   },
@@ -229,6 +239,11 @@ exports[`useListCollections > should handle empty collections 1`] = `
     "source": "https://example.com/source",
     "status": "AVAILABLE",
     "symbol": "MOCK",
+    "tokenIds": [
+      "1",
+      "2",
+      "3",
+    ],
     "type": "ERC721",
     "updatedAt": "2025-05-01T04:39:56.936Z",
   },
@@ -266,6 +281,11 @@ exports[`useListCollections > should handle empty collections 1`] = `
     "source": "https://example.com/source",
     "status": "AVAILABLE",
     "symbol": "MOCK",
+    "tokenIds": [
+      "4",
+      "5",
+      "6",
+    ],
     "type": "ERC721",
     "updatedAt": "2025-05-01T04:39:56.936Z",
   },

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

@@ -72,7 +72,7 @@ exports[`useMarketplaceConfig > should fetch marketplace config and styles succe
     ],
     "enabled": true,
     "ogImage": "https://example.com/og-image.png",
-    "title": "Mock Market Page",
+    "private": false,
   },
   "projectId": NaN,
   "settings": {
@@ -112,6 +112,11 @@ exports[`useMarketplaceConfig > should fetch marketplace config and styles succe
         "projectId": 1,
         "saleAddress": "0x0000000000000000000000000000000000000000",
         "saleBannerUrl": "https://example.com/shop-sale-banner.png",
+        "tokenIds": [
+          "1",
+          "2",
+          "3",
+        ],
         "updatedAt": "2025-03-16T13:04:16.098Z",
       },
       {
@@ -125,12 +130,17 @@ exports[`useMarketplaceConfig > should fetch marketplace config and styles succe
         "projectId": 1,
         "saleAddress": "0x1234567890123456789012345678901234567890",
         "saleBannerUrl": "https://example.com/polygon-shop-sale-banner.png",
+        "tokenIds": [
+          "4",
+          "5",
+          "6",
+        ],
         "updatedAt": "2025-03-16T13:04:16.098Z",
       },
     ],
     "enabled": true,
     "ogImage": "https://example.com/shop-og-image.png",
-    "title": "Mock Shop Page",
+    "private": false,
   },
 }
 `;

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

@@ -1,5 +1,5 @@
 import { renderHook, server, waitFor } from '@test';
-import { http, HttpResponse } from 'msw';
+import { HttpResponse, http } from 'msw';
 import { zeroAddress } from 'viem';
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 import { useDisconnect } from 'wagmi';

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

@@ -0,0 +1,367 @@
+import { renderHook, server, waitFor } from '@test';
+import { HttpResponse, http } from 'msw';
+import { afterEach, describe, expect, it } from 'vitest';
+import { ContractType } from '../../_internal';
+import {
+	mockIndexerEndpoint,
+	mockTokenBalance,
+} from '../../_internal/api/__mocks__/indexer.msw';
+import {
+	laosHandlers,
+	mockTokenBalancesResponse,
+} from '../../_internal/api/__mocks__/laos.msw';
+import { useBalanceOfCollectible } from '../useBalanceOfCollectible';
+
+describe('useBalanceOfCollectible with LAOS', () => {
+	const defaultArgs = {
+		collectionAddress:
+			'0x1234567890123456789012345678901234567890' as `0x${string}`,
+		collectableId: '1',
+		userAddress:
+			'0xuser1234567890123456789012345678901234567890' as `0x${string}`,
+		chainId: 11155111,
+	};
+
+	// Mock marketplace config API response with LAOS collection
+	const laosMarketplaceConfigResponse = {
+		marketplace: {
+			projectId: 1,
+			settings: {
+				style: {},
+				publisherId: 'test-publisher',
+				title: 'Test Marketplace',
+				socials: {
+					twitter: '',
+					discord: '',
+					website: '',
+					tiktok: '',
+					instagram: '',
+					youtube: '',
+				},
+				faviconUrl: '',
+				walletOptions: {
+					walletType: 'UNIVERSAL',
+					oidcIssuers: {},
+					connectors: [],
+					includeEIP6963Wallets: false,
+				},
+				logoUrl: '',
+				fontUrl: '',
+			},
+			market: {
+				enabled: true,
+				title: 'Test Market',
+				bannerUrl: 'https://example.com/banner.png',
+				ogImage: 'https://example.com/og.png',
+			},
+			shop: {
+				enabled: false,
+				title: '',
+				bannerUrl: '',
+				ogImage: '',
+			},
+		},
+		marketCollections: [
+			{
+				id: 1,
+				projectId: 1,
+				chainId: 11155111,
+				itemsAddress: '0x1234567890123456789012345678901234567890',
+				contractType: ContractType.LAOS_ERC_721,
+				bannerUrl: 'https://example.com/banner.png',
+				feePercentage: 0,
+				currencyOptions: [],
+				destinationMarketplace: 'sequence_marketplace_v2',
+			},
+			{
+				id: 2,
+				projectId: 1,
+				chainId: 11155111,
+				itemsAddress: '0x9876543210987654321098765432109876543210',
+				contractType: ContractType.ERC721,
+				bannerUrl: 'https://example.com/banner2.png',
+				feePercentage: 0,
+				currencyOptions: [],
+				destinationMarketplace: 'sequence_marketplace_v2',
+			},
+		],
+		shopCollections: [],
+	};
+
+	// Setup handlers for LAOS and marketplace config
+	afterEach(() => {
+		server.resetHandlers();
+	});
+
+	it('should use LAOS API when collection is LAOS_ERC_721', async () => {
+		// Add LAOS handlers and marketplace config handler
+		server.use(
+			...laosHandlers,
+			http.post('*/rpc/MarketplaceService/LookupMarketplace', () => {
+				return HttpResponse.json(laosMarketplaceConfigResponse);
+			}),
+		);
+
+		const { result } = renderHook(() => useBalanceOfCollectible(defaultArgs));
+
+		// Initially loading
+		expect(result.current.isLoading).toBe(true);
+
+		// Wait for the query to complete
+		await waitFor(() => {
+			expect(result.current.isSuccess).toBe(true);
+		});
+
+		// Should return LAOS API response (first balance)
+		expect(result.current.data).toEqual(mockTokenBalancesResponse.balances[0]);
+		expect(result.current.data?.balance).toBe('5');
+		expect(result.current.data?.contractInfo?.type).toBe('LAOS-ERC-721');
+	});
+
+	it('should use indexer API when collection is regular ERC_721', async () => {
+		const regularCollectionArgs = {
+			...defaultArgs,
+			collectionAddress:
+				'0x9876543210987654321098765432109876543210' as `0x${string}`,
+		};
+
+		server.use(
+			http.post('*/rpc/MarketplaceService/LookupMarketplace', () => {
+				return HttpResponse.json(laosMarketplaceConfigResponse);
+			}),
+			http.post(mockIndexerEndpoint('GetTokenBalances'), () => {
+				return HttpResponse.json({
+					page: { page: 1, pageSize: 10, more: false },
+					balances: [mockTokenBalance],
+				});
+			}),
+		);
+
+		const { result } = renderHook(() =>
+			useBalanceOfCollectible(regularCollectionArgs),
+		);
+
+		await waitFor(() => {
+			expect(result.current.isSuccess).toBe(true);
+		});
+
+		// Should return indexer API response
+		expect(result.current.data).toEqual(mockTokenBalance);
+		expect(result.current.data?.contractInfo?.type).toBe('ERC721');
+	});
+
+	it('should handle LAOS API errors gracefully', async () => {
+		const errorArgs = {
+			...defaultArgs,
+			userAddress:
+				'0x0000000000000000000000000000000000000001' as `0x${string}`, // Special address for 500 error
+		};
+
+		server.use(
+			...laosHandlers,
+			http.post('*/rpc/MarketplaceService/LookupMarketplace', () => {
+				return HttpResponse.json(laosMarketplaceConfigResponse);
+			}),
+		);
+
+		const { result } = renderHook(() => useBalanceOfCollectible(errorArgs));
+
+		await waitFor(() => {
+			expect(result.current.isError).toBe(true);
+		});
+
+		expect(result.current.error).toBeDefined();
+	});
+
+	it('should return null when LAOS API returns empty balances', async () => {
+		const emptyBalanceArgs = {
+			...defaultArgs,
+			userAddress:
+				'0x0000000000000000000000000000000000000003' as `0x${string}`, // Special address for empty response
+		};
+
+		server.use(
+			...laosHandlers,
+			http.post('*/rpc/MarketplaceService/LookupMarketplace', () => {
+				return HttpResponse.json(laosMarketplaceConfigResponse);
+			}),
+		);
+
+		const { result } = renderHook(() =>
+			useBalanceOfCollectible(emptyBalanceArgs),
+		);
+
+		await waitFor(() => {
+			expect(result.current.isSuccess).toBe(true);
+		});
+
+		expect(result.current.data).toBeNull();
+	});
+
+	it('should auto-detect LAOS from marketplace config', async () => {
+		server.use(
+			...laosHandlers,
+			http.post('*/rpc/MarketplaceService/LookupMarketplace', () => {
+				return HttpResponse.json(laosMarketplaceConfigResponse);
+			}),
+		);
+
+		const { result } = renderHook(() => useBalanceOfCollectible(defaultArgs));
+
+		await waitFor(() => {
+			expect(result.current.isSuccess).toBe(true);
+		});
+
+		// Verify it used LAOS API (returns LAOS-specific data structure)
+		expect(result.current.data?.contractInfo?.type).toBe('LAOS-ERC-721');
+		expect(result.current.data?.tokenMetadata).toBeDefined();
+	});
+
+	it('should fallback to indexer when marketplace config is unavailable', async () => {
+		// No marketplace config handler - should fallback to indexer
+		server.use(
+			http.post(mockIndexerEndpoint('GetTokenBalances'), () => {
+				return HttpResponse.json({
+					page: { page: 1, pageSize: 10, more: false },
+					balances: [mockTokenBalance],
+				});
+			}),
+		);
+
+		const { result } = renderHook(() => useBalanceOfCollectible(defaultArgs));
+
+		await waitFor(() => {
+			expect(result.current.isSuccess).toBe(true);
+		});
+
+		// Should use indexer since no marketplace config to determine LAOS
+		expect(result.current.data).toEqual(mockTokenBalance);
+		expect(result.current.data?.contractInfo?.type).toBe('ERC721');
+	});
+
+	it('should handle collection not found in marketplace config', async () => {
+		const unknownCollectionArgs = {
+			...defaultArgs,
+			collectionAddress:
+				'0x0000000000000000000000000000000000000999' as `0x${string}`, // Unknown collection
+		};
+
+		server.use(
+			http.post('*/rpc/MarketplaceService/LookupMarketplace', () => {
+				return HttpResponse.json(laosMarketplaceConfigResponse);
+			}),
+			http.post(mockIndexerEndpoint('GetTokenBalances'), () => {
+				return HttpResponse.json({
+					page: { page: 1, pageSize: 10, more: false },
+					balances: [mockTokenBalance],
+				});
+			}),
+		);
+
+		const { result } = renderHook(() =>
+			useBalanceOfCollectible(unknownCollectionArgs),
+		);
+
+		await waitFor(() => {
+			expect(result.current.isSuccess).toBe(true);
+		});
+
+		// Should fallback to indexer when collection not found in config
+		expect(result.current.data).toEqual(mockTokenBalance);
+		expect(result.current.data?.contractInfo?.type).toBe('ERC721');
+	});
+
+	it('should respect enabled query option for LAOS collections', () => {
+		server.use(
+			...laosHandlers,
+			http.post('*/rpc/MarketplaceService/LookupMarketplace', () => {
+				return HttpResponse.json(laosMarketplaceConfigResponse);
+			}),
+		);
+
+		const { result } = renderHook(() =>
+			useBalanceOfCollectible({
+				...defaultArgs,
+				query: {
+					enabled: false,
+				},
+			}),
+		);
+
+		expect(result.current.isLoading).toBe(false);
+		expect(result.current.data).toBeUndefined();
+	});
+
+	it('should handle LAOS metadata correctly', async () => {
+		server.use(
+			...laosHandlers,
+			http.post('*/rpc/MarketplaceService/LookupMarketplace', () => {
+				return HttpResponse.json(laosMarketplaceConfigResponse);
+			}),
+		);
+
+		const { result } = renderHook(() => useBalanceOfCollectible(defaultArgs));
+
+		await waitFor(() => {
+			expect(result.current.isSuccess).toBe(true);
+		});
+
+		const balance = result.current.data;
+		expect(balance?.tokenMetadata).toBeDefined();
+		expect(balance?.tokenMetadata?.name).toBe('Test Token 1');
+		expect(balance?.tokenMetadata?.description).toBe(
+			'A test token for LAOS testing',
+		);
+		expect(balance?.tokenMetadata?.image).toBe(
+			'https://example.com/token1.png',
+		);
+		expect(balance?.tokenMetadata?.attributes).toEqual([
+			{
+				trait_type: 'Rarity',
+				value: 'Common',
+			},
+		]);
+	});
+
+	it('should pass correct parameters to LAOS API', async () => {
+		let capturedRequestBody: Record<string, unknown> = {};
+
+		server.use(
+			http.post('*/rpc/MarketplaceService/LookupMarketplace', () => {
+				return HttpResponse.json(laosMarketplaceConfigResponse);
+			}),
+			http.post(
+				'https://extensions.api.laosnetwork.io/token/GetTokenBalances',
+				async ({ request }) => {
+					const body = await request.json();
+					capturedRequestBody = body as Record<string, unknown>;
+					return HttpResponse.json(mockTokenBalancesResponse);
+				},
+			),
+		);
+
+		const { result } = renderHook(() => useBalanceOfCollectible(defaultArgs));
+
+		await waitFor(() => {
+			expect(result.current.isSuccess).toBe(true);
+		});
+
+		// Verify LAOS API was called with correct parameters
+		expect(capturedRequestBody).toMatchInlineSnapshot(`
+			{
+			  "accountAddress": "0xuser1234567890123456789012345678901234567890",
+			  "chainId": "11155111",
+			  "contractAddress": "0x1234567890123456789012345678901234567890",
+			  "includeMetadata": true,
+			  "page": {
+			    "sort": [
+			      {
+			        "column": "CREATED_AT",
+			        "order": "DESC",
+			      },
+			    ],
+			  },
+			}
+		`);
+	});
+});

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

@@ -1,5 +1,5 @@
 import { renderHook, server, waitFor } from '@test';
-import { http, HttpResponse } from 'msw';
+import { HttpResponse, http } from 'msw';
 import { zeroAddress } from 'viem';
 import { describe, expect, it } from 'vitest';
 import {

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

@@ -1,5 +1,5 @@
 import { renderHook, server, waitFor } from '@test';
-import { http, HttpResponse } from 'msw';
+import { HttpResponse, http } from 'msw';
 import { beforeEach, describe, expect, it, vi } from 'vitest';
 import {
 	commonWalletMocks,
@@ -81,7 +81,7 @@ describe('useCancelOrder', () => {
 				orderId: mockOrderId,
 				marketplace: MarketplaceKind.sequence_marketplace_v2,
 			});
-		} catch (error) {
+		} catch (_error) {
 			// Error is expected
 		}
 
@@ -171,7 +171,7 @@ describe('useCancelOrder', () => {
 				orderId: mockOrderId,
 				marketplace: MarketplaceKind.sequence_marketplace_v2,
 			});
-		} catch (error) {
+		} catch (_error) {
 			// Error is expected
 		}
 
@@ -235,7 +235,7 @@ describe('useCancelOrder', () => {
 				orderId: mockOrderId,
 				marketplace: MarketplaceKind.sequence_marketplace_v2,
 			});
-		} catch (error) {
+		} catch (_error) {
 			// Error is expected
 		}
 

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

@@ -1,5 +1,5 @@
 import { renderHook, server, waitFor } from '@test';
-import { http, HttpResponse } from 'msw';
+import { HttpResponse, http } from 'msw';
 import { zeroAddress } from 'viem';
 import type { Mock } from 'vitest';
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';