@0xsequence/marketplace-sdk 0.5.2 → 0.5.4

package/src/react/ui/modals/SellModal/hooks/useTransactionSteps.tsx

@@ -1,24 +1,32 @@
+import type { Observable } from '@legendapp/state';
+import { formatUnits } from 'viem';
+import type { Address, Hex } from 'viem';
 import {
-	balanceQueries,
-	collectableKeys,
 	ExecuteType,
-	getMarketplaceClient,
 	type MarketplaceKind,
-	type OrderData,
 	type Step,
 	StepType,
 	type TransactionSteps,
+	balanceQueries,
+	collectableKeys,
+	getMarketplaceClient,
 } from '../../../../_internal';
-import type { ModalCallbacks } from '../../_internal/types';
+import { useAnalytics } from '../../../../_internal/databeat';
 import { TransactionType } from '../../../../_internal/types';
-import { useTransactionStatusModal } from '../../_internal/components/transactionStatusModal';
-import type { Address } from 'viem';
-import type { Observable } from '@legendapp/state';
+import type {
+	SignatureStep,
+	TransactionStep,
+} from '../../../../_internal/utils';
 import { useWallet } from '../../../../_internal/wallet/useWallet';
-import type { SignatureStep } from '../../../../_internal/utils';
-import { useConfig, useGenerateSellTransaction } from '../../../../hooks';
+import {
+	useConfig,
+	useCurrencies,
+	useGenerateSellTransaction,
+} from '../../../../hooks';
 import { useFees } from '../../BuyModal/hooks/useFees';
-
+import { useTransactionStatusModal } from '../../_internal/components/transactionStatusModal';
+import type { ModalCallbacks } from '../../_internal/types';
+import type { SellOrder } from './useSell';
 export type ExecutionState = 'approval' | 'sell' | null;
 
 interface UseTransactionStepsArgs {
@@ -26,7 +34,7 @@ interface UseTransactionStepsArgs {
 	chainId: string;
 	collectionAddress: string;
 	marketplace: MarketplaceKind;
-	ordersData: Array<OrderData>;
+	ordersData: Array<SellOrder>;
 	callbacks?: ModalCallbacks;
 	closeMainModal: () => void;
 	steps$: Observable<TransactionSteps>;
@@ -46,10 +54,16 @@ export const useTransactionSteps = ({
 	const { show: showTransactionStatusModal } = useTransactionStatusModal();
 	const sdkConfig = useConfig();
 	const marketplaceClient = getMarketplaceClient(chainId, sdkConfig);
+	const analytics = useAnalytics();
+
 	const { amount, receiver } = useFees({
 		chainId: Number(chainId),
 		collectionAddress: collectionAddress,
 	});
+
+	const { data: currencies } = useCurrencies({
+		chainId: Number(chainId),
+	});
 	const { generateSellTransactionAsync, isPending: generatingSteps } =
 		useGenerateSellTransaction({
 			chainId,
@@ -99,7 +113,7 @@ export const useTransactionSteps = ({
 
 			const hash = await wallet.handleSendTransactionStep(
 				Number(chainId),
-				approvalStep as any,
+				approvalStep as TransactionStep,
 			);
 
 			await wallet.handleConfirmTransactionStep(hash, Number(chainId));
@@ -128,7 +142,8 @@ export const useTransactionSteps = ({
 				throw new Error('No transaction or signature step found');
 			}
 
-			let hash, orderId: string | undefined;
+			let hash: Hex | undefined;
+			let orderId: string | undefined;
 
 			if (transactionStep) {
 				hash = await executeTransaction({ transactionStep });
@@ -159,10 +174,37 @@ export const useTransactionSteps = ({
 
 			if (orderId) {
 				// no need to wait for receipt, because the order is already created
-
 				steps$.transaction.isExecuting.set(false);
 				steps$.transaction.exist.set(false);
 			}
+
+			if (hash || orderId) {
+				const currency = currencies?.find(
+					(currency) =>
+						currency.contractAddress === ordersData[0].currencyAddress,
+				);
+				const currencyDecimal = currency?.decimals || 0;
+				const currencySymbol = currency?.symbol || '';
+				const currencyValueRaw = Number(ordersData[0].pricePerToken);
+				const currencyValueDecimal = Number(
+					formatUnits(BigInt(currencyValueRaw), currencyDecimal),
+				);
+
+				analytics.trackSellItems({
+					props: {
+						marketplaceKind: marketplace,
+						collectionAddress,
+						currencyAddress: ordersData[0].currencyAddress,
+						currencySymbol,
+						chainId,
+						txnHash: hash || '',
+					},
+					nums: {
+						currencyValueDecimal,
+						currencyValueRaw,
+					},
+				});
+			}
 		} catch (error) {
 			steps$.transaction.isExecuting.set(false);
 			steps$.transaction.exist.set(false);
@@ -179,7 +221,7 @@ export const useTransactionSteps = ({
 
 		const hash = await wallet.handleSendTransactionStep(
 			Number(chainId),
-			transactionStep as any,
+			transactionStep as TransactionStep,
 		);
 
 		return hash;

package/src/react/ui/modals/SuccessfulPurchaseModal/__tests__/Modal.test.tsx

@@ -1,4 +1,3 @@
-import '@testing-library/jest-dom/vitest';
 import { render, screen, cleanup } from '../../../../_internal/test-utils';
 import { describe, it, expect, vi, beforeEach } from 'vitest';
 import SuccessfulPurchaseModal, { useSuccessfulPurchaseModal } from '..';

package/src/react/ui/modals/_internal/components/actionModal/ErrorModal.tsx

@@ -1,4 +1,4 @@
-import { Box } from '@0xsequence/design-system';
+import { Box, Text } from '@0xsequence/design-system';
 import { ActionModal } from './ActionModal';
 
 interface ErrorModalProps {
@@ -30,7 +30,9 @@ export const ErrorModal = ({
 			alignItems="center"
 			padding="4"
 		>
-			{message || 'Error loading item details'}
+			<Text color="text80" fontFamily="body">
+				{message || 'Error loading item details'}
+			</Text>
 		</Box>
 	</ActionModal>
 );

package/src/react/ui/modals/_internal/components/currencyOptionsSelect/__tests__/index.test.tsx

@@ -1,13 +1,18 @@
-import '@testing-library/jest-dom/vitest';
-import { screen, cleanup, fireEvent } from '@testing-library/react';
+import { screen, cleanup, fireEvent, waitFor } from '@testing-library/react';
 import { describe, it, expect, vi, beforeEach } from 'vitest';
 import { observable } from '@legendapp/state';
+import type { UseQueryResult } from '@tanstack/react-query';
 import CurrencyOptionsSelect from '..';
 import type { Currency } from '../../../../../../_internal';
 import { useCurrencies } from '../../../../../../hooks';
 import { mockCurrencies } from '../../../../../../_internal/api/__mocks__/marketplace.msw';
 import { render } from '../../../../../../_internal/test-utils';
 
+// Mock the hooks
+vi.mock('../../../../../../hooks', () => ({
+	useCurrencies: vi.fn(),
+}));
+
 // Mock the Skeleton component
 vi.mock('@0xsequence/design-system', async (importOriginal) => {
 	const actual = await importOriginal();
@@ -19,96 +24,163 @@ vi.mock('@0xsequence/design-system', async (importOriginal) => {
 });
 
 describe('CurrencyOptionsSelect', () => {
-	const defaultProps = {
+	const createDefaultProps = () => ({
 		collectionAddress: '0xCollection' as `0x${string}`,
 		chainId: 1,
 		selectedCurrency$: observable<Currency | null | undefined>(null),
 		secondCurrencyAsDefault: false,
 		includeNativeCurrency: false,
-	};
+	});
 
 	beforeEach(() => {
 		cleanup();
-		// Reset all mocks
 		vi.clearAllMocks();
 	});
 
 	it('should render loading skeleton when currencies are loading', () => {
-		vi.mocked(useCurrencies as any).mockReturnValueOnce({
+		vi.mocked(useCurrencies).mockReturnValue({
 			data: undefined,
 			isLoading: true,
-		});
+		} as UseQueryResult<Currency[], Error>);
 
-		render(<CurrencyOptionsSelect {...defaultProps} />);
+		const props = createDefaultProps();
+		render(<CurrencyOptionsSelect {...props} />);
 		expect(screen.getByTestId('skeleton')).toBeInTheDocument();
 	});
 
-	it('should set first currency as default when currencies load', () => {
-		const selectedCurrency$ = observable<Currency | null | undefined>(null);
-		render(
-			<CurrencyOptionsSelect
-				{...defaultProps}
-				selectedCurrency$={selectedCurrency$}
-			/>,
-		);
+	it('should set first currency as default when currencies load', async () => {
+		vi.mocked(useCurrencies).mockReturnValue({
+			data: mockCurrencies,
+			isLoading: false,
+		} as UseQueryResult<Currency[], Error>);
+
+		const props = createDefaultProps();
+		render(<CurrencyOptionsSelect {...props} />);
+
+		await waitFor(() => {
+			const selectedCurrency = props.selectedCurrency$.get();
+			expect(selectedCurrency).toBeDefined();
+			expect(selectedCurrency?.contractAddress).toBe(
+				mockCurrencies[0].contractAddress,
+			);
+			expect(selectedCurrency?.symbol).toBe(mockCurrencies[0].symbol);
+		});
 
-		expect(selectedCurrency$.get()).toEqual(mockCurrencies[0]);
+		expect(screen.getByText(mockCurrencies[0].symbol)).toBeInTheDocument();
 	});
 
-	it('should set second currency as default when secondCurrencyAsDefault is true', () => {
-		const selectedCurrency$ = observable<Currency | null | undefined>(null);
-		render(
-			<CurrencyOptionsSelect
-				{...defaultProps}
-				selectedCurrency$={selectedCurrency$}
-				secondCurrencyAsDefault={true}
-			/>,
-		);
+	it('should set second currency as default when secondCurrencyAsDefault is true', async () => {
+		vi.mocked(useCurrencies).mockReturnValue({
+			data: mockCurrencies,
+			isLoading: false,
+		} as UseQueryResult<Currency[], Error>);
+
+		const props = createDefaultProps();
+		render(<CurrencyOptionsSelect {...props} secondCurrencyAsDefault={true} />);
+
+		await waitFor(() => {
+			const selectedCurrency = props.selectedCurrency$.get();
+			expect(selectedCurrency).toBeDefined();
+			expect(selectedCurrency?.contractAddress).toBe(
+				mockCurrencies[1].contractAddress,
+			);
+			expect(selectedCurrency?.symbol).toBe(mockCurrencies[1].symbol);
+		});
 
-		expect(selectedCurrency$.get()).toEqual(mockCurrencies[1]);
+		expect(screen.getByText(mockCurrencies[1].symbol)).toBeInTheDocument();
 	});
 
-	it('should update selected currency when user selects a different option', () => {
-		const firstCurrency = mockCurrencies[0];
-		const secondCurrency = mockCurrencies[1];
+	it('should update selected currency when user selects a different option', async () => {
+		vi.mocked(useCurrencies).mockReturnValue({
+			data: mockCurrencies,
+			isLoading: false,
+		} as UseQueryResult<Currency[], Error>);
 
-		const selectedCurrency$ = observable(firstCurrency);
+		const props = createDefaultProps();
+		render(<CurrencyOptionsSelect {...props} />);
 
-		const { getByRole, getByText } = render(
-			<CurrencyOptionsSelect
-				{...defaultProps}
-				selectedCurrency$={selectedCurrency$}
-			/>,
-		);
+		// Wait for initial currency to be set
+		await waitFor(() => {
+			expect(props.selectedCurrency$.get()).toBeDefined();
+		});
 
-		// Find and click the select to open the dropdown
-		const selectButton = getByRole('combobox');
+		// Find and click the select element
+		const selectButton = screen.getByRole('combobox');
 		fireEvent.click(selectButton);
 
-		// Find and click the WETH option in the dropdown
-		const wethOption = getByText(secondCurrency.symbol);
-		fireEvent.click(wethOption);
+		// Find and click the second currency option
+		const secondOption = screen.getByText(mockCurrencies[1].symbol);
+		fireEvent.click(secondOption);
 
-		expect(selectedCurrency$.get()).toEqual(secondCurrency);
+		// Verify the new selection is reflected in both the observable and UI
+		expect(props.selectedCurrency$.get()?.contractAddress).toBe(
+			mockCurrencies[1].contractAddress,
+		);
+		expect(props.selectedCurrency$.get()?.symbol).toBe(
+			mockCurrencies[1].symbol,
+		);
+		expect(screen.getByText(mockCurrencies[1].symbol)).toBeInTheDocument();
 	});
 
-	it('should maintain selected currency when currencies reload', () => {
-		const selectedCurrency$ = observable(mockCurrencies[0]);
+	it('should maintain selected currency when currencies reload', async () => {
+		const useCurrenciesMock = vi.mocked(useCurrencies);
 
-		const { rerender } = render(
-			<CurrencyOptionsSelect
-				{...defaultProps}
-				selectedCurrency$={selectedCurrency$}
-			/>,
-		);
+		// Initial load with currencies
+		useCurrenciesMock.mockReturnValue({
+			data: mockCurrencies,
+			isLoading: false,
+		} as UseQueryResult<Currency[], Error>);
+
+		const props = createDefaultProps();
+		render(<CurrencyOptionsSelect {...props} />);
+
+		// Wait for initial currency to be set and select the second currency
+		await waitFor(() => {
+			expect(props.selectedCurrency$.get()).toBeDefined();
+		});
+
+		const selectButton = screen.getByRole('combobox');
+		fireEvent.click(selectButton);
+		const secondOption = screen.getByText(mockCurrencies[1].symbol);
+		fireEvent.click(secondOption);
 
-		rerender(
-			<CurrencyOptionsSelect
-				{...defaultProps}
-				selectedCurrency$={selectedCurrency$}
-			/>,
+		// Verify second currency is selected
+		expect(props.selectedCurrency$.get()?.contractAddress).toBe(
+			mockCurrencies[1].contractAddress,
 		);
 
-		expect(selectedCurrency$.get()).toEqual(mockCurrencies[0]);
+		// Simulate reload by setting loading state
+		useCurrenciesMock.mockReturnValue({
+			data: undefined,
+			isLoading: true,
+			error: null,
+		} as unknown as UseQueryResult<Currency[], Error>);
+
+		// Verify the selected currency remains the same during loading
+		expect(props.selectedCurrency$.get()?.contractAddress).toBe(
+			mockCurrencies[1].contractAddress,
+		);
+		expect(props.selectedCurrency$.get()?.symbol).toBe(
+			mockCurrencies[1].symbol,
+		);
+		expect(screen.getByText(mockCurrencies[1].symbol)).toBeInTheDocument();
+
+		// Simulate reload completion
+		useCurrenciesMock.mockReturnValue({
+			data: mockCurrencies,
+			isLoading: false,
+			error: null,
+		} as unknown as UseQueryResult<Currency[], Error>);
+
+		// Verify the same currency is still selected after reload
+		await waitFor(() => {
+			expect(props.selectedCurrency$.get()?.contractAddress).toBe(
+				mockCurrencies[1].contractAddress,
+			);
+			expect(props.selectedCurrency$.get()?.symbol).toBe(
+				mockCurrencies[1].symbol,
+			);
+		});
+		expect(screen.getByText(mockCurrencies[1].symbol)).toBeInTheDocument();
 	});
 });

package/src/react/ui/modals/_internal/components/currencyOptionsSelect/index.tsx

@@ -5,7 +5,6 @@ import { useEffect } from 'react';
 import type { Hex } from 'viem';
 import type { ChainId, Currency } from '../../../../../_internal';
 import { useCurrencies } from '../../../../../hooks';
-import { useCurrencyOptions } from '../../../../../hooks/useCurrencyOptions';
 import {
 	CustomSelect,
 	type SelectItem,
@@ -27,10 +26,9 @@ const CurrencyOptionsSelect = observer(function CurrencyOptionsSelect({
 	includeNativeCurrency,
 }: CurrencyOptionsSelectProps) {
 	const currency = selectedCurrency$.get();
-	const currencyOptions = useCurrencyOptions({ collectionAddress });
 	const { data: currencies, isLoading: currenciesLoading } = useCurrencies({
 		chainId,
-		currencyOptions,
+		collectionAddress,
 		includeNativeCurrency,
 	});
 

package/src/react/ui/modals/_internal/components/priceInput/__tests__/index.test.tsx

@@ -1,5 +1,3 @@
-import '@testing-library/jest-dom/vitest';
-
 import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
 import { observable } from '@legendapp/state';
 import PriceInput from '..';
@@ -17,7 +15,7 @@ vi.mock('../hooks/usePriceInput', () => ({
 		value: '0',
 		handlePriceChange: (value: string) => {
 			try {
-				if (value === '0' || !value || isNaN(Number(value))) {
+				if (value === '0' || !value || Number.isNaN(Number(value))) {
 					return;
 				}
 				onPriceChange?.(value);

package/src/react/ui/modals/_internal/components/transactionDetails/index.tsx

@@ -31,8 +31,8 @@ export default function TransactionDetails({
 
 	const marketplaceFeePercentage =
 		data?.collections.find(
-			(collection) => collection.collectionAddress === collectionAddress,
-		)?.marketplaceFeePercentage || DEFAULT_MARKETPLACE_FEE_PERCENTAGE;
+			(collection) => collection.address === collectionAddress,
+		)?.feePercentage || DEFAULT_MARKETPLACE_FEE_PERCENTAGE;
 	const { data: royaltyPercentage, isLoading: royaltyPercentageLoading } =
 		useRoyaltyPercentage({
 			chainId,

package/src/react/ui/modals/_internal/components/transactionStatusModal/__tests__/TransactionStatusModal.test.tsx

@@ -4,7 +4,7 @@ import {
 	screen,
 	waitFor,
 } from '../../../../../../_internal/test-utils';
-import '@testing-library/jest-dom/vitest';
+
 import TransactionStatusModal from '../index';
 import { transactionStatusModal$ } from '../store';
 import type { ShowTransactionStatusModalArgs } from '../index';
@@ -33,7 +33,7 @@ describe('TransactionStatusModal', () => {
 	beforeEach(() => {
 		transactionStatusModal$.close();
 		vi.clearAllMocks();
-		(useTransactionStatus as any).mockReturnValue('PENDING');
+		vi.mocked(useTransactionStatus).mockReturnValue('PENDING');
 	});
 
 	it('should not render when closed', () => {
@@ -44,7 +44,7 @@ describe('TransactionStatusModal', () => {
 	});
 
 	it('should show processing state when transaction is processing', async () => {
-		(useTransactionStatus as any).mockReturnValue('PENDING');
+		vi.mocked(useTransactionStatus).mockReturnValue('PENDING');
 		transactionStatusModal$.open(mockTransactionArgs);
 		render(<TransactionStatusModal />);
 
@@ -60,7 +60,7 @@ describe('TransactionStatusModal', () => {
 	});
 
 	it('should show success state when transaction is successful', async () => {
-		(useTransactionStatus as any).mockReturnValue('SUCCESS');
+		vi.mocked(useTransactionStatus).mockReturnValue('SUCCESS');
 		transactionStatusModal$.open(mockTransactionArgs);
 		render(<TransactionStatusModal />);
 
@@ -76,7 +76,7 @@ describe('TransactionStatusModal', () => {
 	});
 
 	it('should show failed state when transaction fails', async () => {
-		(useTransactionStatus as any).mockReturnValue('FAILED');
+		vi.mocked(useTransactionStatus).mockReturnValue('FAILED');
 		transactionStatusModal$.open(mockTransactionArgs);
 		render(<TransactionStatusModal />);
 
@@ -90,7 +90,7 @@ describe('TransactionStatusModal', () => {
 	});
 
 	it('should show timeout state when transaction times out', async () => {
-		(useTransactionStatus as any).mockReturnValue('TIMEOUT');
+		vi.mocked(useTransactionStatus).mockReturnValue('TIMEOUT');
 		transactionStatusModal$.open(mockTransactionArgs);
 		render(<TransactionStatusModal />);
 
@@ -105,7 +105,7 @@ describe('TransactionStatusModal', () => {
 
 	it('should call onSuccess callback when transaction succeeds', async () => {
 		const onSuccess = vi.fn();
-		(useTransactionStatus as any).mockImplementation(() => {
+		vi.mocked(useTransactionStatus).mockImplementation(() => {
 			onSuccess({
 				hash: mockTransactionArgs.hash,
 			});
@@ -128,7 +128,7 @@ describe('TransactionStatusModal', () => {
 	it('should call onError callback when transaction fails', async () => {
 		const onError = vi.fn();
 		const error = new Error('Transaction failed');
-		(useTransactionStatus as any).mockImplementation(() => {
+		vi.mocked(useTransactionStatus).mockImplementation(() => {
 			onError(error);
 			return 'FAILED';
 		});

package/src/react/ui/modals/_internal/components/transactionStatusModal/hooks/useTransactionStatus.ts

@@ -25,6 +25,7 @@ const useTransactionStatus = (
 				: skipToken,
 	});
 
+	// biome-ignore lint/correctness/useExhaustiveDependencies: <explanation>
 	useEffect(() => {
 		if (!hash) {
 			setStatus('SUCCESS');

package/src/types/builder-types.ts

@@ -0,0 +1,79 @@
+import type { OrderbookKind } from '../react/_internal/api/marketplace.gen';
+
+// Manual copy of the types from builder
+export enum MarketplaceWallet {
+	UNIVERSAL = 'UNIVERSAL',
+	EMBEDDED = 'EMBEDDED',
+}
+
+export enum FilterCondition {
+	ENTIRE_KEY = 'ENTIRE_KEY',
+	SPECIFIC_VALUE = 'SPECIFIC_VALUE',
+}
+
+export enum MarketplaceType { // This is only used for marketplace v1
+	AMM = 'AMM',
+	P2P = 'P2P',
+	SEQUENCE = 'SEQUENCE',
+	ORDERBOOK = 'ORDERBOOK',
+}
+
+export interface MarketplaceWalletOptions {
+	walletType: MarketplaceWallet;
+	oidcIssuers: { [key: string]: string };
+	connectors: Array<string>;
+	includeEIP6963Wallets: boolean;
+}
+
+export interface MetadataFilterRule {
+	key: string;
+	condition: FilterCondition;
+	value?: string;
+}
+
+export interface CollectionFilterSettings {
+	filterOrder: Array<string>;
+	exclusions: Array<MetadataFilterRule>;
+}
+
+export interface MarketplaceCollection {
+	marketplaceType: MarketplaceType;
+	chainId: number;
+	address: string;
+	exchanges: Array<string>;
+	bannerUrl: string;
+	feePercentage: number;
+	currencyOptions: Array<string>;
+	destinationMarketplace: OrderbookKind;
+	filterSettings?: CollectionFilterSettings;
+}
+
+export interface MarketplaceSocials {
+	twitter: string;
+	discord: string;
+	website: string;
+	tiktok: string;
+	instagram: string;
+	youtube: string;
+}
+
+export interface MarketplaceSettings {
+	publisherId: string;
+	title: string;
+	shortDescription: string;
+	socials: MarketplaceSocials;
+	faviconUrl: string;
+	landingBannerUrl: string;
+	collections: Array<MarketplaceCollection>;
+	walletOptions: MarketplaceWalletOptions;
+	landingPageLayout: string;
+	logoUrl: string;
+	bannerUrl: string;
+	fontUrl?: string;
+	ogImage?: string;
+}
+
+export interface MarketplaceConfig extends MarketplaceSettings {
+	cssString: string;
+	manifestUrl: string;
+}

package/src/types/index.ts

@@ -1,4 +1,4 @@
 export * from './api-types';
-export * from './marketplace-config';
 export * from './sdk-config';
 export * from './types';
+export * from './builder-types';

package/src/utils/__tests__/get-public-rpc-client.test.ts

@@ -50,6 +50,7 @@ describe('getPublicRpcClient', () => {
 			expect(network).toBeDefined();
 			const client = getPublicRpcClient(chainId);
 
+			// biome-ignore lint/style/noNonNullAssertion: <explanation>
 			expect(client.chain!.rpcUrls.default.http).toEqual([network!.rpcUrl]);
 		});
 
@@ -59,6 +60,7 @@ describe('getPublicRpcClient', () => {
 			expect(network).toBeDefined();
 			const client = getPublicRpcClient(chainId);
 
+			// biome-ignore lint/style/noNonNullAssertion: <explanation>
 			expect(client.chain!.nativeCurrency).toEqual(network!.nativeToken);
 		});
 	});

package/src/utils/getMarketplaceDetails.ts

@@ -75,8 +75,8 @@ export function getMarketplaceDetails({
 	kind,
 }: MarketplaceDetailsProp) {
 	if (
-		kind == MarketplaceKind.sequence_marketplace_v1 ||
-		kind == MarketplaceKind.sequence_marketplace_v2
+		kind === MarketplaceKind.sequence_marketplace_v1 ||
+		kind === MarketplaceKind.sequence_marketplace_v2
 	) {
 		return MARKETPLACES.sequence;
 	}