@0xsequence/marketplace-sdk 2.0.1 → 2.0.2

package/src/react/ui/modals/BuyModal/internal/buildTrailsMarketBuyActions.ts

@@ -0,0 +1,259 @@
+import {
+	type Address,
+	type ApprovalStep,
+	type BuyStep,
+	ContractType,
+	type Hash,
+	MarketplaceKind,
+	type Order,
+	type OrderbookKind,
+} from '@0xsequence/api-client';
+import { buildErc20Approve, type Call, self } from '0xtrails';
+import { encodeFunctionData, zeroAddress } from 'viem';
+import { getConduitAddressForOrderbook } from '../../../../../utils/getConduitAddressForOrderbook';
+import { normalizeMarketplaceKind } from '../../../../../utils/normalizeMarketplace';
+import { OPENSEA_CHAIN_CURRENCIES } from '../../_internal/constants/opensea-currencies';
+
+export type TrailsMarketBuyCall = Call;
+
+export type TrailsMarketBuyActions = {
+	calls: TrailsMarketBuyCall[];
+	paymentTokenAddress: Address;
+	paymentAmount: bigint;
+};
+
+type BuildTrailsMarketBuyActionsParams = {
+	chainId: number;
+	buyStep: BuyStep;
+	marketOrder: Order;
+	contractType: ContractType.ERC721 | ContractType.ERC1155;
+	recipientAddress: Address;
+	approvalStep?: ApprovalStep;
+	quantity?: bigint;
+};
+
+const WETH_ABI = [
+	{
+		type: 'function',
+		name: 'withdraw',
+		stateMutability: 'nonpayable',
+		inputs: [{ name: 'wad', type: 'uint256' }],
+		outputs: [],
+	},
+] as const;
+
+const ERC721_TRANSFER_FROM_ABI = [
+	{
+		type: 'function',
+		name: 'transferFrom',
+		stateMutability: 'nonpayable',
+		inputs: [
+			{ name: 'from', type: 'address' },
+			{ name: 'to', type: 'address' },
+			{ name: 'tokenId', type: 'uint256' },
+		],
+		outputs: [],
+	},
+] as const;
+
+const ERC1155_SAFE_TRANSFER_FROM_ABI = [
+	{
+		type: 'function',
+		name: 'safeTransferFrom',
+		stateMutability: 'nonpayable',
+		inputs: [
+			{ name: 'from', type: 'address' },
+			{ name: 'to', type: 'address' },
+			{ name: 'id', type: 'uint256' },
+			{ name: 'amount', type: 'uint256' },
+			{ name: 'data', type: 'bytes' },
+		],
+		outputs: [],
+	},
+] as const;
+
+const OPENSEA_FULFILL_WITHOUT_RECIPIENT_SELECTORS = new Set([
+	'0xfb0f3ee1', // fulfillBasicOrder(...)
+	'0xb1b747c3', // fulfillOrder(...)
+]);
+
+const isNativeCurrency = (currencyAddress: Address) =>
+	currencyAddress.toLowerCase() === zeroAddress;
+
+const getPaymentAmount = ({
+	buyStep,
+	marketOrder,
+	isErc20Payment,
+}: {
+	buyStep: BuyStep;
+	marketOrder: Order;
+	isErc20Payment: boolean;
+}) => {
+	if (isErc20Payment) {
+		return buyStep.price > 0n ? buyStep.price : marketOrder.priceAmount;
+	}
+
+	if (buyStep.value > 0n) {
+		return buyStep.value;
+	}
+
+	return buyStep.price > 0n ? buyStep.price : marketOrder.priceAmount;
+};
+
+const getWrappedNativeCurrencyAddress = (chainId: number) =>
+	OPENSEA_CHAIN_CURRENCIES[chainId.toString()]?.wrappedNativeCurrency.address as
+		| Address
+		| undefined;
+
+const buildWrappedNativeWithdrawCall = ({
+	wrappedNativeAddress,
+	amount,
+}: {
+	wrappedNativeAddress: Address;
+	amount: bigint;
+}): TrailsMarketBuyCall => ({
+	to: wrappedNativeAddress,
+	data: encodeFunctionData({
+		abi: WETH_ABI,
+		functionName: 'withdraw',
+		args: [amount],
+	}),
+});
+
+const isOpenSeaFulfillWithoutRecipient = (calldata: Hash) =>
+	OPENSEA_FULFILL_WITHOUT_RECIPIENT_SELECTORS.has(
+		calldata.slice(0, 10).toLowerCase(),
+	);
+
+const buildOpenSeaNftTransferCall = ({
+	marketOrder,
+	contractType,
+	recipientAddress,
+	quantity,
+}: {
+	marketOrder: Order;
+	contractType: ContractType.ERC721 | ContractType.ERC1155;
+	recipientAddress: Address;
+	quantity: bigint;
+}): TrailsMarketBuyCall | undefined => {
+	if (marketOrder.tokenId === undefined) {
+		return undefined;
+	}
+
+	const collectionAddress = marketOrder.collectionContractAddress as Address;
+	const executorAddress = self();
+
+	if (contractType === ContractType.ERC1155) {
+		return {
+			to: collectionAddress,
+			data: encodeFunctionData({
+				abi: ERC1155_SAFE_TRANSFER_FROM_ABI,
+				functionName: 'safeTransferFrom',
+				args: [
+					executorAddress,
+					recipientAddress,
+					marketOrder.tokenId,
+					quantity,
+					'0x',
+				],
+			}),
+		};
+	}
+
+	return {
+		to: collectionAddress,
+		data: encodeFunctionData({
+			abi: ERC721_TRANSFER_FROM_ABI,
+			functionName: 'transferFrom',
+			args: [executorAddress, recipientAddress, marketOrder.tokenId],
+		}),
+	};
+};
+
+export function buildTrailsMarketBuyActions({
+	chainId,
+	buyStep,
+	marketOrder,
+	contractType,
+	recipientAddress,
+	approvalStep,
+	quantity = 1n,
+}: BuildTrailsMarketBuyActionsParams): TrailsMarketBuyActions | undefined {
+	const calls: TrailsMarketBuyCall[] = [];
+	const currencyAddress = marketOrder.priceCurrencyAddress;
+	const isErc20Payment = !isNativeCurrency(currencyAddress);
+	const paymentAmount = getPaymentAmount({
+		buyStep,
+		marketOrder,
+		isErc20Payment,
+	});
+	let paymentTokenAddress = currencyAddress;
+
+	if (isErc20Payment && paymentAmount > 0n) {
+		if (approvalStep) {
+			calls.push({
+				to: approvalStep.to,
+				data: approvalStep.data,
+			});
+		} else {
+			const spenderAddress = getConduitAddressForOrderbook(
+				marketOrder.marketplace as unknown as OrderbookKind,
+			);
+
+			if (spenderAddress) {
+				calls.push(
+					buildErc20Approve({
+						tokenAddress: currencyAddress,
+						spender: spenderAddress,
+						amount: paymentAmount,
+					}),
+				);
+			}
+		}
+	} else if (!isErc20Payment) {
+		const wrappedNativeAddress = getWrappedNativeCurrencyAddress(chainId);
+		if (!wrappedNativeAddress) {
+			return undefined;
+		}
+
+		paymentTokenAddress = wrappedNativeAddress;
+		if (paymentAmount > 0n) {
+			calls.push(
+				buildWrappedNativeWithdrawCall({
+					wrappedNativeAddress,
+					amount: paymentAmount,
+				}),
+			);
+		}
+	}
+
+	calls.push({
+		to: buyStep.to,
+		data: buyStep.data,
+		...(!isErc20Payment && paymentAmount > 0n
+			? { value: paymentAmount, sweepTokens: [zeroAddress] }
+			: {}),
+	});
+
+	const isOpenSeaOrder =
+		normalizeMarketplaceKind(marketOrder.marketplace) ===
+		MarketplaceKind.opensea;
+	if (isOpenSeaOrder && isOpenSeaFulfillWithoutRecipient(buyStep.data)) {
+		const nftTransferCall = buildOpenSeaNftTransferCall({
+			marketOrder,
+			contractType,
+			recipientAddress,
+			quantity,
+		});
+
+		if (nftTransferCall) {
+			calls.push(nftTransferCall);
+		}
+	}
+
+	return {
+		calls,
+		paymentTokenAddress,
+		paymentAmount,
+	};
+}

package/src/react/ui/modals/BuyModal/internal/buyModalContext.ts

@@ -1,6 +1,14 @@
-import { ContractType, type Hash } from '@0xsequence/api-client';
-import { useSupportedChains } from '0xtrails';
+import {
+	type Address,
+	ContractType,
+	findApprovalStep,
+	findBuyStep,
+	type Hash,
+} from '@0xsequence/api-client';
+import { encodeDestinationCalls, useSupportedChains } from '0xtrails';
+import { useMemo } from 'react';
 import { type Chain, formatUnits } from 'viem';
+import { useAccount } from 'wagmi';
 import { TransactionType } from '../../../../_internal';
 import { useConfig } from '../../../../hooks';
 import { useBuyTransaction } from '../../../../hooks/transactions/useBuyTransaction';
@@ -10,15 +18,25 @@ import { useTransactionStatusModal } from '../../_internal/components/transactio
 import { useBuyModal } from '..';
 import { useBuyModalData } from '../hooks/useBuyModalData';
 import { useBuyModalProps } from '../store';
+import { buildTrailsMarketBuyActions } from './buildTrailsMarketBuyActions';
 import { determineCheckoutMode } from './determineCheckoutMode';
 
+type TrailsDestination = {
+	recipient: Address;
+	destinationCalldata: Hash;
+	paymentTokenAddress: Address;
+	paymentAmount: bigint;
+};
+
 export function useBuyModalContext() {
 	const config = useConfig();
 	const modalProps = useBuyModalProps();
 	const checkoutModeConfig: CheckoutMode = config.checkoutMode ?? 'trails';
 	const { close } = useBuyModal();
 	const transactionStatusModal = useTransactionStatusModal();
-	const { supportedChains, isLoadingChains } = useSupportedChains();
+	const { address: userWalletAddress } = useAccount();
+	const { data: supportedChains = [], isLoading: isLoadingChains } =
+		useSupportedChains();
 
 	const {
 		collectible,
@@ -34,16 +52,18 @@ export function useBuyModalContext() {
 		refetchQueries,
 	} = useBuyModalData();
 
+	const contractType =
+		collection?.type === ContractType.ERC1155
+			? ContractType.ERC1155
+			: ContractType.ERC721;
+
 	const transactionData = useBuyTransaction({
 		modalProps,
 		primarySalePrice: {
 			amount: primarySaleItem?.priceAmount,
 			currencyAddress: primarySaleItem?.currencyAddress,
 		},
-		contractType:
-			collection?.type === ContractType.ERC1155
-				? ContractType.ERC1155
-				: ContractType.ERC721,
+		contractType,
 	});
 	const steps = transactionData.data?.steps;
 	const canBeUsedWithTrails =
@@ -58,7 +78,47 @@ export function useBuyModalContext() {
 
 	const isLoading = isLoadingSteps || isLoadingChains || isBuyModalDataLoading;
 
-	const buyStep = steps?.find((step) => step.id === 'buy');
+	const buyStep = steps ? findBuyStep(steps) : undefined;
+	const approvalStep = steps ? findApprovalStep(steps) : undefined;
+
+	const trailsDestination = useMemo<TrailsDestination | undefined>(() => {
+		if (!isMarket || !marketOrder || !buyStep || !userWalletAddress) {
+			return undefined;
+		}
+
+		const trailsMarketBuyActions = buildTrailsMarketBuyActions({
+			chainId: modalProps.chainId,
+			buyStep,
+			marketOrder,
+			contractType,
+			recipientAddress: userWalletAddress,
+			approvalStep,
+		});
+		if (!trailsMarketBuyActions) {
+			return undefined;
+		}
+
+		const destination = encodeDestinationCalls({
+			calls: trailsMarketBuyActions.calls,
+			tokenAddress: trailsMarketBuyActions.paymentTokenAddress,
+			sweepTarget: userWalletAddress,
+		});
+
+		return {
+			recipient: destination.recipient,
+			destinationCalldata: destination.destinationCalldata,
+			paymentTokenAddress: trailsMarketBuyActions.paymentTokenAddress,
+			paymentAmount: trailsMarketBuyActions.paymentAmount,
+		};
+	}, [
+		approvalStep,
+		buyStep,
+		contractType,
+		isMarket,
+		marketOrder,
+		modalProps.chainId,
+		userWalletAddress,
+	]);
 
 	const checkoutMode = determineCheckoutMode({
 		checkoutModeConfig,
@@ -66,9 +126,16 @@ export function useBuyModalContext() {
 		canBeUsedWithTrails,
 	});
 
+	const paymentAmount =
+		trailsDestination?.paymentAmount ??
+		(buyStep
+			? buyStep.price > 0n
+				? buyStep.price
+				: buyStep.value
+			: undefined);
 	const formattedAmount =
-		currency?.decimals && buyStep?.price
-			? formatUnits(BigInt(buyStep.price), currency.decimals)
+		currency?.decimals !== undefined && paymentAmount !== undefined
+			? formatUnits(paymentAmount, currency.decimals)
 			: undefined;
 
 	const handleTransactionSuccess = (hash: Hash) => {
@@ -131,8 +198,10 @@ export function useBuyModalContext() {
 		collection,
 		primarySaleItem,
 		marketOrder,
+		isMarket,
 		isShop,
 		buyStep,
+		trailsDestination,
 		isLoading,
 		checkoutMode,
 		formattedAmount,

package/src/react/ui/modals/BuyModal/internal/cryptoPaymentModalContext.tsx

@@ -2,8 +2,9 @@ import type { Address, Hash } from '@0xsequence/api-client';
 import { ChevronLeftIcon, Text } from '@0xsequence/design-system';
 import type { ReactNode } from 'react';
 import { useState } from 'react';
-import type { Hex } from 'viem';
+import { zeroAddress, type Hex } from 'viem';
 import { useSendTransaction } from 'wagmi';
+import { getErrorMessage } from '../../../../../utils/getErrorMessage';
 import { formatPrice } from '../../../../../utils/price';
 import { type Step, StepType } from '../../../../_internal';
 import { useConnectorMetadata } from '../../../../hooks';
@@ -74,6 +75,31 @@ type CryptoPaymentModalReturn = {
 	};
 };
 
+const toErrorWithDetails = (error: unknown): Error => {
+	if (error instanceof Error) {
+		return error;
+	}
+
+	if (typeof error === 'object' && error !== null) {
+		const errorLike = error as Record<string, unknown>;
+		let message = 'An unexpected error occurred.';
+
+		if (typeof errorLike.message === 'string') {
+			message = errorLike.message;
+		} else {
+			try {
+				message = JSON.stringify(errorLike);
+			} catch {
+				message = 'An unexpected error occurred.';
+			}
+		}
+
+		return Object.assign(new Error(message), errorLike);
+	}
+
+	return new Error(String(error));
+};
+
 export function useCryptoPaymentModalContext({
 	chainId,
 	steps,
@@ -101,7 +127,6 @@ export function useCryptoPaymentModalContext({
 		marketOrder,
 		primarySaleItem,
 		isMarket,
-		isShop,
 		collection,
 		isLoading: isLoadingBuyModalData,
 	} = useBuyModalData();
@@ -115,11 +140,16 @@ export function useCryptoPaymentModalContext({
 	const priceCurrencyAddress = isMarket
 		? marketOrder?.priceCurrencyAddress
 		: (primarySaleItem?.currencyAddress as Address);
+	const listedPriceAmount = BigInt(priceAmount || 0);
+	const buyStepPriceAmount = buyStep.price ? BigInt(buyStep.price) : listedPriceAmount;
+	const buyStepValue = buyStep.value ? BigInt(buyStep.value) : buyStepPriceAmount;
+	const requiredBalance =
+		priceCurrencyAddress === zeroAddress ? buyStepValue : buyStepPriceAmount;
 	const isAnyTransactionPending = isApproving || isExecuting;
 
 	const { data, isLoading: isLoadingBalance } = useHasSufficientBalance({
 		chainId,
-		value: BigInt(priceAmount || 0),
+		value: requiredBalance,
 		tokenAddress: priceCurrencyAddress as Address,
 	});
 
@@ -137,7 +167,6 @@ export function useCryptoPaymentModalContext({
 	} = useExecuteBundledTransactions({
 		chainId,
 		approvalStep,
-		priceAmount: BigInt(priceAmount || 0),
 	});
 
 	const waas = useSelectWaasFeeOptionsStore();
@@ -169,7 +198,10 @@ export function useCryptoPaymentModalContext({
 			throw errorDetails;
 		}
 
-		await ensureCorrectChainAsync(chainId);
+		const isOnCorrectChain = await ensureCorrectChainAsync(chainId);
+		if (!isOnCorrectChain) {
+			throw new Error('Failed to switch to the required network.');
+		}
 
 		const hash = await sendTransactionAsync({
 			to,
@@ -195,12 +227,10 @@ export function useCryptoPaymentModalContext({
 			await executeTransaction(approvalStep);
 			setApprovalStep(undefined);
 		} catch (error) {
-			const errorObj =
-				error instanceof Error ? error : new Error(String(error));
+			const errorObj = toErrorWithDetails(error);
 			setError({
 				title: 'Approval failed',
-				message:
-					errorObj.message || 'Failed to approve token. Please try again.',
+				message: getErrorMessage(errorObj),
 				details: errorObj,
 			});
 			console.error('Approval transaction failed:', error);
@@ -222,7 +252,7 @@ export function useCryptoPaymentModalContext({
 	const handleTransactionFailed = (error: Error) => {
 		setError({
 			title: 'Transaction failed',
-			message: error.message,
+			message: getErrorMessage(error),
 			details: error,
 		});
 
@@ -242,12 +272,10 @@ export function useCryptoPaymentModalContext({
 
 			onSuccess(hash as Hash);
 		} catch (error) {
-			const errorObj =
-				error instanceof Error ? error : new Error(String(error));
+			const errorObj = toErrorWithDetails(error);
 			setError({
 				title: 'Purchase failed',
-				message:
-					errorObj.message || 'Failed to complete purchase. Please try again.',
+				message: getErrorMessage(errorObj),
 				details: errorObj,
 			});
 			console.error('Buy transaction failed:', error);
@@ -261,7 +289,7 @@ export function useCryptoPaymentModalContext({
 	};
 
 	const formattedPrice = formatPrice(
-		BigInt(priceAmount || 0),
+		buyStepPriceAmount,
 		currency?.decimals || 0,
 	);
 	const isFree = formattedPrice === '0';
@@ -330,7 +358,6 @@ export function useCryptoPaymentModalContext({
 		!isAnyTransactionPending &&
 		!isFeeSelectionVisible;
 
-	const needsBundledTransactions = isShop && !!approvalStep;
 	const canBuy =
 		hasSufficientBalance &&
 		!isLoadingBalance &&
@@ -338,7 +365,7 @@ export function useCryptoPaymentModalContext({
 		(isSequenceConnector ? true : !approvalStep) &&
 		!isAnyTransactionPending &&
 		!isFeeSelectionVisible &&
-		(needsBundledTransactions ? isBundledTransactionsReady : true);
+		isBundledTransactionsReady;
 
 	const result: CryptoPaymentModalReturn = {
 		data: {

package/src/react/ui/modals/MakeOfferModal/internal/context.ts

@@ -5,6 +5,7 @@ import { zeroAddress } from 'viem';
 import { useAccount } from 'wagmi';
 import { dateToUnixTime } from '../../../../../utils/date';
 import { getConduitAddressForOrderbook } from '../../../../../utils/getConduitAddressForOrderbook';
+import { isOpenSeaOrderbook } from '../../../../../utils/normalizeMarketplace';
 import {
 	useCollectibleMarketLowestListing,
 	useCollectibleMetadata,
@@ -113,7 +114,7 @@ export function useMakeOfferModalContext() {
 		amountRaw: state.priceInput?.toString(),
 		query: {
 			enabled:
-				state.orderbookKind === OrderbookKind.opensea &&
+				isOpenSeaOrderbook(state.orderbookKind) &&
 				!!selectedCurrency?.contractAddress &&
 				!!state.priceInput,
 		},

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

@@ -4,6 +4,7 @@ import type { Address } from '@0xsequence/api-client';
 import { Skeleton } from '@0xsequence/design-system';
 import { useEffect } from 'react';
 import { compareAddress } from '../../../../../../utils';
+import { isOpenSeaOrderbook } from '../../../../../../utils/normalizeMarketplace';
 import { type Currency, OrderbookKind } from '../../../../../_internal';
 import { useCurrencyList } from '../../../../../hooks';
 import {
@@ -41,7 +42,7 @@ function CurrencyOptionsSelect({
 
 	// Filter currencies for OpenSea
 	let filteredCurrencies = currencies;
-	if (currencies && orderbookKind === OrderbookKind.opensea && modalType) {
+	if (currencies && isOpenSeaOrderbook(orderbookKind) && modalType) {
 		const openseaCurrency = getOpenseaCurrencyForChain(chainId, modalType);
 		if (openseaCurrency) {
 			// Filter to only show the OpenSea-supported currency

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

@@ -15,6 +15,7 @@ import { useAccount } from 'wagmi';
 import type { Currency, Price } from '../../../../../../types';
 import { calculateTotalOfferCost, cn } from '../../../../../../utils';
 import { validateOpenseaOfferDecimals } from '../../../../../../utils/price';
+import { isOpenSeaOrderbook } from '../../../../../../utils/normalizeMarketplace';
 import {
 	useConvertPriceToUSD,
 	useTokenCurrencyBalance,
@@ -74,13 +75,13 @@ export default function PriceInput({
 		useConvertPriceToUSD({
 			chainId,
 			currencyAddress: currencyAddress ?? zeroAddress,
-			amountRaw: priceAmountRaw?.toString(),
-			query: {
-				enabled:
-					orderbookKind === OrderbookKind.opensea &&
-					!!currencyAddress &&
-					!!priceAmountRaw,
-			},
+		amountRaw: priceAmountRaw?.toString(),
+		query: {
+			enabled:
+				isOpenSeaOrderbook(orderbookKind) &&
+				!!currencyAddress &&
+				!!priceAmountRaw,
+		},
 		});
 
 	useEffect(() => {
@@ -160,7 +161,7 @@ export default function PriceInput({
 	);
 
 	const openseaLowestPriceCriteriaMet =
-		orderbookKind === OrderbookKind.opensea &&
+		isOpenSeaOrderbook(orderbookKind) &&
 		conversion?.usdAmount !== undefined &&
 		conversion.usdAmount >= 0.01;
 
@@ -205,7 +206,7 @@ export default function PriceInput({
 		if (!price || !onPriceChange) return;
 
 		// Validate OpenSea decimal constraints for offers
-		if (orderbookKind === OrderbookKind.opensea && modalType === 'offer') {
+		if (isOpenSeaOrderbook(orderbookKind) && modalType === 'offer') {
 			const validation = validateOpenseaOfferDecimals(newValue);
 			if (!validation.isValid) {
 				setOpenseaDecimalError(validation.errorMessage || null);
@@ -318,7 +319,7 @@ export default function PriceInput({
 			{!balanceError &&
 				priceAmountRaw !== 0n &&
 				!openseaLowestPriceCriteriaMet &&
-				orderbookKind === OrderbookKind.opensea &&
+				isOpenSeaOrderbook(orderbookKind) &&
 				!isConversionLoading &&
 				modalType === 'offer' &&
 				!openseaDecimalError && (
@@ -332,7 +333,7 @@ export default function PriceInput({
 
 			{!balanceError &&
 				openseaDecimalError &&
-				orderbookKind === OrderbookKind.opensea &&
+				isOpenSeaOrderbook(orderbookKind) &&
 				modalType === 'offer' && (
 					<Text className="font-body font-medium text-xs" color="negative">
 						{openseaDecimalError}

package/src/react/ui/modals/_internal/helpers/currency.test.ts

@@ -0,0 +1,27 @@
+import { OrderbookKind } from '@0xsequence/api-client';
+import * as MarketplaceMocks from '@0xsequence/api-client/mocks/marketplace';
+import { describe, expect, it } from 'vitest';
+import type { Currency } from '../../../../_internal';
+import { filterCurrenciesForOrderbook } from './currency';
+
+const { mockCurrencies } = MarketplaceMocks;
+const typedMockCurrencies: Currency[] = mockCurrencies.map((currency) => ({
+	...currency,
+	contractAddress: currency.contractAddress as `0x${string}`,
+}));
+
+describe('filterCurrenciesForOrderbook', () => {
+	it('should apply OpenSea listing currency limits to Magic Eden orderbooks', () => {
+		const filteredCurrencies = filterCurrenciesForOrderbook(
+			typedMockCurrencies,
+			OrderbookKind.magic_eden,
+			1,
+			'listing',
+		);
+
+		expect(filteredCurrencies).toHaveLength(1);
+		expect(filteredCurrencies[0]?.contractAddress).toBe(
+			typedMockCurrencies[0]?.contractAddress,
+		);
+	});
+});