@0xsequence/marketplace-sdk 1.1.0 → 1.1.1

package/dist/{react-BLJ4DkPx.js → react-DE852KeT.js}

@@ -1,28 +1,37 @@
 'use client';
 import { DEFAULT_MARKETPLACE_FEE_PERCENTAGE } from "./src-Dz2CfBL0.js";
 import { BaseError as BaseError$1, ChainSwitchError, InvalidContractTypeError, NoWalletConnectedError, TransactionExecutionError, TransactionSignatureError, UserRejectedRequestError as UserRejectedRequestError$1 } from "./transaction-DZUW5RHu.js";
-import { balanceQueries, collectableKeys, getMarketplaceClient, getQueryClient, getSequenceApiClient } from "./api-DuLKn__v.js";
-import { CollectionStatus, ContractType, ExecuteType, OrderSide, OrderbookKind, PropertyType, StepType, WalletKind } from "./marketplace.gen-w2YvbEEo.js";
+import { balanceQueries, collectableKeys, getMarketplaceClient, getQueryClient, getSequenceApiClient, marketplaceApiURL } from "./api-BoO0V5aJ.js";
+import { CollectionStatus, ContractType, ExecuteType, OrderSide, OrderbookKind, PropertyType, StepType, WalletKind } from "./marketplace.gen-ksUafDqS.js";
 import { getNetwork, getPresentableChainName } from "./network-DtmiMhcg.js";
 import { PROVIDER_ID, TransactionType } from "./_internal-DkS2VUn5.js";
 import { CollectibleCardAction } from "./types-B_-cnkcP.js";
-import { EIP2981_ABI, SequenceMarketplaceV1_ABI } from "./marketplace-BYY8OloA.js";
-import { ERC721_SALE_ABI_V0, ERC721_SALE_ABI_V1 } from "./primary-sale-DOmNDq2P.js";
-import { ERC1155_ABI, ERC721_ABI } from "./token-CcyLz8Z8.js";
-import { calculateEarningsAfterFees, cn as cn$1, compareAddress, formatPriceWithFee, truncateMiddle } from "./utils-BZEkdqWK.js";
-import { marketplaceConfigOptions } from "./marketplaceConfig-BTy75Mbf.js";
-import { SalesContractVersion, useSalesContractABI } from "./contracts-D72LBOX3.js";
-import { balanceOfCollectibleOptions, checkoutOptionsQueryOptions, checkoutOptionsSalesContractQueryOptions, collectibleQueryOptions, collectionBalanceDetailsQueryOptions, collectionDetailsQueryOptions, collectionQueryOptions, comparePricesQueryOptions, convertPriceToUSDQueryOptions, countListingsForCollectibleQueryOptions, countOfCollectablesQueryOptions, countOfPrimarySaleItemsOptions, countOffersForCollectibleQueryOptions, currencyQueryOptions, filtersQueryOptions, floorOrderQueryOptions, getTokenRangesQueryOptions, highestOfferQueryOptions, inventoryOptions, listBalancesOptions, listCollectibleActivitiesQueryOptions, listCollectiblesPaginatedQueryOptions, listCollectiblesQueryOptions, listCollectionActivitiesQueryOptions, listCollectionsQueryOptions, listListingsForCollectibleQueryOptions, listOffersForCollectibleQueryOptions, listPrimarySaleItemsQueryOptions, listTokenMetadataQueryOptions, lowestListingQueryOptions, marketCurrenciesQueryOptions, primarySaleItemsCountQueryOptions, searchTokenMetadataQueryOptions, tokenSuppliesQueryOptions } from "./queries-EMA5CcwY.js";
-import { waitForTransactionReceipt } from "./waitForTransactionReceipt-B08YZiDY.js";
-import { CalendarIcon_default, CartIcon_default, InfoIcon_default } from "./CartIcon-C8zbor8H.js";
-import { FooterName, PriceDisplay, SaleDetailsPill, TokenTypeBalancePill } from "./components-CUv-wQr8.js";
+import { EIP2981_ABI, SequenceMarketplaceV1_ABI } from "./marketplace-NQB-sEQL.js";
+import { ERC721_SALE_ABI_V0, ERC721_SALE_ABI_V1 } from "./primary-sale-1u4QlPdA.js";
+import { ERC1155_ABI, ERC721_ABI } from "./token-Cv7l2ZaL.js";
+import { calculateEarningsAfterFees, cn as cn$1, compareAddress, formatPriceWithFee, truncateMiddle } from "./utils-BfpDVibN.js";
+import { marketplaceConfigOptions } from "./marketplaceConfig-UHQMM9fq.js";
+import { SalesContractVersion, useSalesContractABI } from "./contracts-BP_0vX48.js";
+import { balanceOfCollectibleOptions, collectibleQueryOptions, countOfCollectablesQueryOptions, listCollectibleActivitiesQueryOptions, listCollectiblesPaginatedQueryOptions, listCollectiblesQueryOptions } from "./collectibles-C_H8jMGH.js";
+import { listBalancesOptions } from "./listBalances-BxpxBCvn.js";
+import { collectionBalanceDetailsQueryOptions, collectionDetailsQueryOptions, collectionQueryOptions, listCollectionActivitiesQueryOptions, listCollectionsQueryOptions } from "./collections-CKummc-R.js";
+import { checkoutOptionsQueryOptions, checkoutOptionsSalesContractQueryOptions, currencyQueryOptions, filtersQueryOptions } from "./market-C3HV-awQ.js";
+import { marketCurrenciesQueryOptions } from "./marketCurrencies-sKrTX0og.js";
+import { countItemsOrdersForCollectionQueryOptions, countListingsForCollectibleQueryOptions, countOffersForCollectibleQueryOptions, floorOrderQueryOptions, getCountOfFilteredOrdersQueryOptions, highestOfferQueryOptions, listItemsOrdersForCollectionPaginatedQueryOptions, listItemsOrdersForCollectionQueryOptions, listListingsForCollectibleQueryOptions, listOffersForCollectibleQueryOptions, lowestListingQueryOptions } from "./orders-DnFfZAXV.js";
+import { inventoryOptions } from "./inventory-Dd7TazvZ.js";
+import { countOfPrimarySaleItemsOptions, listPrimarySaleItemsQueryOptions, primarySaleItemsCountQueryOptions } from "./primary-sales-Dmsi6bqj.js";
+import { getTokenRangesQueryOptions, listTokenMetadataQueryOptions, searchTokenMetadataQueryOptions, tokenSuppliesQueryOptions } from "./tokens-cGxMadd8.js";
+import { comparePricesQueryOptions, convertPriceToUSDQueryOptions } from "./utils-BCgNhBFR.js";
+import { waitForTransactionReceipt } from "./waitForTransactionReceipt-DieAnV52.js";
+import { CalendarIcon_default, CartIcon_default, InfoIcon_default } from "./CartIcon-Bt3rQYGk.js";
+import { FooterName, PriceDisplay, SaleDetailsPill, TokenTypeBalancePill } from "./components-CosnX7F9.js";
 import { NetworkType, networks } from "@0xsequence/network";
 import { useAccount, useBalance, useChainId, usePublicClient, useReadContract, useReadContracts, useSendTransaction, useSignMessage, useSignTypedData, useSwitchChain, useWriteContract } from "wagmi";
 import { useChain, useOpenConnectModal, useWaasFeeOptions } from "@0xsequence/connect";
 import { Suspense, createContext, lazy, useCallback, useContext, useEffect, useMemo, useRef, useState } from "react";
 import { QueryClientProvider, queryOptions, skipToken, useInfiniteQuery, useMutation, useQuery } from "@tanstack/react-query";
 import { TransactionStatus } from "@0xsequence/indexer";
-import { AddIcon, Button, CheckmarkIcon, ChevronDownIcon, Divider, DropdownMenuCheckboxItem, DropdownMenuContent, DropdownMenuPortal, DropdownMenuRoot, DropdownMenuTrigger, ExternalLinkIcon, IconButton, Image, Modal, NetworkImage, NumericInput, Select, Skeleton, Spinner, SubtractIcon, Text, TextInput, ThemeProvider, TokenImage, Tooltip, WarningIcon, cn } from "@0xsequence/design-system";
+import { AddIcon, Button, CheckmarkIcon, ChevronDownIcon, ChevronRightIcon, ChevronUpIcon, CloseIcon, Divider, DropdownMenuCheckboxItem, DropdownMenuContent, DropdownMenuPortal, DropdownMenuRoot, DropdownMenuTrigger, ExternalLinkIcon, IconButton, Image, Modal, NetworkImage, NumericInput, Select, Skeleton, Spinner, SubtractIcon, Text, TextInput, ThemeProvider, TimeIcon, TokenImage, Tooltip, WarningIcon, cn } from "@0xsequence/design-system";
 import { Fragment, jsx, jsxs } from "react/jsx-runtime";
 import * as dn from "dnum";
 import { BaseError, UserRejectedRequestError, WaitForTransactionReceiptTimeoutError, decodeFunctionData, encodeFunctionData, erc20Abi, erc721Abi, formatUnits, hexToBigInt, isAddress, isHex, maxUint256, parseEventLogs, parseUnits, toHex, zeroAddress } from "viem";
@@ -33,7 +42,7 @@ import { useSelector } from "@xstate/store/react";
 import { createSerializer, parseAsBoolean, parseAsJson, parseAsString, useQueryState } from "nuqs";
 import { SequenceCheckoutProvider, useERC1155SaleContractCheckout, useSelectPaymentModal } from "@0xsequence/checkout";
 import { Show, observer, use$ } from "@legendapp/state/react";
-import { addDays, differenceInDays, format, formatDistanceToNow, isSameDay, startOfDay } from "date-fns";
+import { addDays, differenceInDays, endOfDay, format, formatDistanceToNow, getHours, getMinutes, isSameDay, setHours, setMinutes, startOfDay } from "date-fns";
 import { avalanche, optimism } from "viem/chains";
 import { DayPicker } from "react-day-picker";
 import { addDays as addDays$1 } from "date-fns/addDays";
@@ -101,6 +110,36 @@ const useAnalytics = () => {
 	return useContext(MarketplaceSdkContext).analytics;
 };
 
+//#endregion
+//#region src/react/providers/analytics-provider.tsx
+function AnalyticsProvider({ config, children }) {
+	const { address, isConnected } = useAccount();
+	const isWindowDefined = typeof window !== "undefined";
+	const analytics = useMemo(() => {
+		const server = "https://nodes.sequence.app";
+		const auth = {};
+		auth.headers = { "X-Access-Key": config.projectAccessKey };
+		return new DatabeatAnalytics(server, auth, {
+			defaultEnabled: true,
+			initProps: () => {
+				return { origin: isWindowDefined ? window.location.origin : "" };
+			}
+		});
+	}, [config.projectAccessKey, isWindowDefined]);
+	useEffect(() => {
+		if (!isConnected || !address) {
+			analytics?.reset();
+			return;
+		}
+		analytics?.identify(address.toLowerCase());
+	}, [
+		analytics,
+		address,
+		isConnected
+	]);
+	return /* @__PURE__ */ jsx(Fragment, { children: children(analytics) });
+}
+
 //#endregion
 //#region src/react/providers/theme-provider.tsx
 const ThemeProvider$1 = ({ children, theme, root }) => {
@@ -118,36 +157,29 @@ const ThemeProvider$1 = ({ children, theme, root }) => {
 const MarketplaceSdkContext = createContext({});
 function MarketplaceProvider({ config, children, openConnectModal }) {
 	if (config.projectAccessKey === "" || !config.projectAccessKey) throw new InvalidProjectAccessKeyError(config.projectAccessKey);
-	const isWindowDefined = typeof window !== "undefined";
-	const analytics = useMemo(() => {
-		const server = "https://nodes.sequence.app";
-		const auth = {};
-		auth.headers = { "X-Access-Key": config.projectAccessKey };
-		return new DatabeatAnalytics(server, auth, {
-			defaultEnabled: true,
-			initProps: () => {
-				return { origin: isWindowDefined ? window.location.origin : "" };
-			}
-		});
-	}, [config.projectAccessKey, isWindowDefined]);
-	if (openConnectModal) {
-		const context = {
-			...config,
-			openConnectModal,
-			analytics
-		};
-		return /* @__PURE__ */ jsx(MarketplaceSdkContext.Provider, {
-			value: context,
-			children: /* @__PURE__ */ jsx(ThemeProvider$1, { children: /* @__PURE__ */ jsx("div", {
-				id: PROVIDER_ID,
-				children
-			}) })
-		});
-	}
-	return /* @__PURE__ */ jsx(MarketplaceProviderWithSequenceConnect, {
+	return /* @__PURE__ */ jsx(AnalyticsProvider, {
 		config,
-		analytics,
-		children: /* @__PURE__ */ jsx(ThemeProvider$1, { children })
+		children: (analytics) => {
+			if (openConnectModal) {
+				const context = {
+					...config,
+					openConnectModal,
+					analytics
+				};
+				return /* @__PURE__ */ jsx(MarketplaceSdkContext.Provider, {
+					value: context,
+					children: /* @__PURE__ */ jsx(ThemeProvider$1, { children: /* @__PURE__ */ jsx("div", {
+						id: PROVIDER_ID,
+						children
+					}) })
+				});
+			}
+			return /* @__PURE__ */ jsx(MarketplaceProviderWithSequenceConnect, {
+				config,
+				analytics,
+				children: /* @__PURE__ */ jsx(ThemeProvider$1, { children })
+			});
+		}
 	});
 }
 function MarketplaceQueryClientProvider({ children }) {
@@ -938,7 +970,7 @@ const useSellModal = (callbacks) => {
 
 //#endregion
 //#region src/react/hooks/data/market/useListMarketCardData.tsx
-function useListMarketCardData({ collectionAddress, chainId, orderbookKind, collectionType, filterOptions, searchText, showListedOnly = false, onCollectibleClick, onCannotPerformAction, prioritizeOwnerActions, assetSrcPrefixUrl }) {
+function useListMarketCardData({ collectionAddress, chainId, orderbookKind, collectionType, filterOptions, searchText, showListedOnly = false, priceFilters, onCollectibleClick, onCannotPerformAction, prioritizeOwnerActions, assetSrcPrefixUrl, hideQuantitySelector }) {
 	const { address: accountAddress } = useAccount();
 	const { show: showSellModal } = useSellModal();
 	const { data: collectiblesList, isLoading: collectiblesListIsLoading, fetchNextPage, hasNextPage, isFetchingNextPage, error: collectiblesListError } = useListCollectibles({
@@ -948,7 +980,8 @@ function useListMarketCardData({ collectionAddress, chainId, orderbookKind, coll
 		filter: {
 			includeEmpty: !showListedOnly,
 			searchText,
-			properties: filterOptions
+			properties: filterOptions,
+			prices: priceFilters
 		},
 		query: { enabled: !!collectionAddress && !!chainId }
 	});
@@ -984,6 +1017,7 @@ function useListMarketCardData({ collectionAddress, chainId, orderbookKind, coll
 					onCannotPerformAction,
 					prioritizeOwnerActions,
 					assetSrcPrefixUrl,
+					hideQuantitySelector,
 					onOfferClick: ({ order }) => {
 						if (!accountAddress) return;
 						if (balance) {
@@ -1066,6 +1100,69 @@ function useMarketCurrencies(params) {
 	return useQuery({ ...queryOptions$1 });
 }
 
+//#endregion
+//#region src/react/hooks/data/orders/useCountItemsOrdersForCollection.tsx
+/**
+* Hook to get the count of orders for a collection
+*
+* Counts the total number of active orders (listings) for all tokens
+* in a collection. Useful for displaying order counts in collection UI.
+*
+* @param params - Configuration parameters
+* @param params.chainId - The chain ID (must be number, e.g., 1 for Ethereum, 137 for Polygon)
+* @param params.collectionAddress - The collection contract address
+* @param params.filter - Optional filter criteria for orders
+* @param params.query - Optional React Query configuration
+*
+* @returns Query result containing the count of orders
+*
+* @example
+* Basic usage:
+* ```typescript
+* const { data: orderCount, isLoading } = useCountItemsOrdersForCollection({
+*   chainId: 137,
+*   collectionAddress: '0x...'
+* })
+* ```
+*
+* @example
+* With filter:
+* ```typescript
+* const { data: filteredCount } = useCountItemsOrdersForCollection({
+*   chainId: 137,
+*   collectionAddress: '0x...',
+*   filter: {
+*     marketplace: [MarketplaceKind.sequence_marketplace_v2]
+*   }
+* })
+* ```
+*
+* @example
+* Combined with list hook:
+* ```typescript
+* const { data: totalCount } = useCountItemsOrdersForCollection({
+*   chainId: 137,
+*   collectionAddress: '0x...'
+* })
+*
+* const { data: orders } = useListItemsOrdersForCollection({
+*   chainId: 137,
+*   collectionAddress: '0x...'
+* })
+*
+* return <div>Showing {orders?.pages[0]?.listings.length ?? 0} of {totalCount} orders</div>
+* ```
+*/
+function useCountItemsOrdersForCollection(params) {
+	const defaultConfig = useConfig();
+	const { config = defaultConfig,...rest } = params;
+	const queryOptions$1 = countItemsOrdersForCollectionQueryOptions({
+		config,
+		...rest
+	});
+	return useQuery({ ...queryOptions$1 });
+}
+
 //#endregion
 //#region src/react/hooks/data/orders/useCountListingsForCollectible.tsx
 /**
@@ -1213,6 +1310,18 @@ function useFloorOrder(params) {
 	return useQuery({ ...queryOptions$1 });
 }
 
+//#endregion
+//#region src/react/hooks/data/orders/useGetCountOfFilteredOrders.tsx
+function useGetCountOfFilteredOrders(params) {
+	const defaultConfig = useConfig();
+	const { config = defaultConfig,...rest } = params;
+	const queryOptions$1 = getCountOfFilteredOrdersQueryOptions({
+		config,
+		...rest
+	});
+	return useQuery({ ...queryOptions$1 });
+}
+
 //#endregion
 //#region src/react/hooks/data/orders/useHighestOffer.tsx
 /**
@@ -1263,6 +1372,138 @@ function useHighestOffer(params) {
 	return useQuery({ ...queryOptions$1 });
 }
 
+//#endregion
+//#region src/react/hooks/data/orders/useListItemsOrdersForCollection.tsx
+/**
+* Hook to fetch all listings for a collection with infinite pagination support
+*
+* Fetches active listings (sales) for all tokens in a collection from the marketplace
+* with support for filtering and infinite scroll pagination.
+*
+* @param params - Configuration parameters
+* @param params.chainId - The chain ID (must be number, e.g., 1 for Ethereum, 137 for Polygon)
+* @param params.collectionAddress - The collection contract address
+* @param params.filter - Optional filtering parameters (marketplace, currencies, etc.)
+* @param params.query - Optional React Query configuration
+*
+* @returns Infinite query result containing listings data with pagination
+*
+* @example
+* Basic usage:
+* ```typescript
+* const { data, isLoading, fetchNextPage, hasNextPage } = useListItemsOrdersForCollection({
+*   chainId: 137,
+*   collectionAddress: '0x...'
+* })
+* ```
+*
+* @example
+* With filtering:
+* ```typescript
+* const { data, fetchNextPage } = useListItemsOrdersForCollection({
+*   chainId: 1,
+*   collectionAddress: '0x...',
+*   filter: {
+*     marketplace: [MarketplaceKind.sequence_marketplace_v2],
+*     currencies: ['0x...']
+*   }
+* })
+* ```
+*
+* @example
+* Accessing paginated data:
+* ```typescript
+* const { data } = useListItemsOrdersForCollection({
+*   chainId: 137,
+*   collectionAddress: '0x...'
+* })
+*
+* const allListings = data?.pages.flatMap(page => page.listings) ?? []
+* ```
+*/
+function useListItemsOrdersForCollection(params) {
+	const defaultConfig = useConfig();
+	const { config = defaultConfig,...rest } = params;
+	const queryOptions$1 = listItemsOrdersForCollectionQueryOptions({
+		config,
+		...rest
+	});
+	return useInfiniteQuery({ ...queryOptions$1 });
+}
+
+//#endregion
+//#region src/react/hooks/data/orders/useListItemsOrdersForCollectionPaginated.tsx
+/**
+* Hook to fetch all listings for a collection with pagination support
+*
+* Fetches active listings (sales) for all tokens in a collection from the marketplace
+* with support for filtering and pagination. Unlike the infinite query version,
+* this hook fetches a specific page of results.
+*
+* @param params - Configuration parameters
+* @param params.chainId - The chain ID (must be number, e.g., 1 for Ethereum, 137 for Polygon)
+* @param params.collectionAddress - The collection contract address
+* @param params.side - Order side (listing or bid)
+* @param params.filter - Optional filtering parameters (marketplace, currencies, etc.)
+* @param params.page - Page number to fetch (default: 1)
+* @param params.pageSize - Number of items per page (default: 30)
+* @param params.query - Optional React Query configuration
+*
+* @returns Query result containing listings data for the specific page
+*
+* @example
+* Basic usage:
+* ```typescript
+* const { data, isLoading } = useListItemsOrdersForCollectionPaginated({
+*   chainId: 137,
+*   collectionAddress: '0x...',
+*   side: OrderSide.listing,
+*   page: 1,
+*   pageSize: 20
+* })
+* ```
+*
+* @example
+* With filtering:
+* ```typescript
+* const { data } = useListItemsOrdersForCollectionPaginated({
+*   chainId: 1,
+*   collectionAddress: '0x...',
+*   side: OrderSide.listing,
+*   page: 2,
+*   pageSize: 50,
+*   filter: {
+*     marketplace: [MarketplaceKind.sequence_marketplace_v2],
+*     currencies: ['0x...']
+*   }
+* })
+* ```
+*
+* @example
+* Controlled pagination:
+* ```typescript
+* const [currentPage, setCurrentPage] = useState(1);
+* const { data, isLoading } = useListItemsOrdersForCollectionPaginated({
+*   chainId: 137,
+*   collectionAddress: '0x...',
+*   side: OrderSide.listing,
+*   page: currentPage,
+*   pageSize: 25
+* });
+*
+* const hasMorePages = data?.page?.more;
+* ```
+*/
+function useListItemsOrdersForCollectionPaginated(params) {
+	const defaultConfig = useConfig();
+	const { config = defaultConfig,...rest } = params;
+	const queryOptions$1 = listItemsOrdersForCollectionPaginatedQueryOptions({
+		config,
+		...rest
+	});
+	return useQuery({ ...queryOptions$1 });
+}
+
 //#endregion
 //#region src/react/hooks/data/orders/useListListingsForCollectible.tsx
 /**
@@ -2500,6 +2741,7 @@ function isTransactionStep(step) {
 		StepType.createListing
 	].includes(step.id);
 }
+const clamp = (val, min, max) => Math.max(min, Math.min(max, val));
 
 //#endregion
 //#region src/react/hooks/transactions/useProcessStep.ts
@@ -3003,22 +3245,34 @@ const validateFilters = (value) => {
 	if (!Array.isArray(value)) return [];
 	return value.filter((f) => typeof f === "object" && typeof f.name === "string" && Object.values(PropertyType).includes(f.type));
 };
+const validatePriceFilters = (value) => {
+	if (!Array.isArray(value)) return [];
+	return value.filter((f) => typeof f === "object" && typeof f.contractAddress === "string" && (f.min === void 0 || typeof f.min === "string") && (f.max === void 0 || typeof f.max === "string"));
+};
 const filtersParser = parseAsJson(validateFilters).withDefault([]);
 const searchParser = parseAsString.withDefault("");
 const listedOnlyParser = parseAsBoolean.withDefault(false);
+const priceFilterParser = parseAsBoolean.withDefault(false);
+const priceFiltersParser = parseAsJson(validatePriceFilters).withDefault([]);
 const serialize = createSerializer({
 	filters: filtersParser,
 	search: searchParser,
-	listedOnly: listedOnlyParser
+	listedOnly: listedOnlyParser,
+	priceFilter: priceFilterParser,
+	priceFilters: priceFiltersParser
 }, { urlKeys: {
 	filters: "f",
 	search: "q",
-	listedOnly: "l"
+	listedOnly: "l",
+	priceFilter: "p",
+	priceFilters: "pf"
 } });
 function useFilterState() {
 	const [filterOptions, setFilterOptions] = useQueryState("filters", filtersParser);
 	const [searchText, setSearchText] = useQueryState("search", searchParser);
 	const [showListedOnly, setShowListedOnly] = useQueryState("listedOnly", listedOnlyParser);
+	const [showPriceFilter, setShowPriceFilter] = useQueryState("priceFilter", priceFilterParser);
+	const [priceFilters, setPriceFilters] = useQueryState("priceFilters", priceFiltersParser);
 	const helpers = useMemo(() => ({
 		getFilter: (name) => {
 			return filterOptions?.find((f) => f.name === name);
@@ -3092,24 +3346,52 @@ function useFilterState() {
 				max
 			}]);
 		},
+		setPriceFilter: (contractAddress, min, max) => {
+			const otherPriceFilters = priceFilters?.filter((f) => f.contractAddress !== contractAddress) ?? [];
+			if (!min && !max) {
+				setPriceFilters(otherPriceFilters);
+				return;
+			}
+			const newPriceFilter = {
+				contractAddress,
+				...min && { min },
+				...max && { max }
+			};
+			setPriceFilters([...otherPriceFilters, newPriceFilter]);
+		},
+		getPriceFilter: (contractAddress) => {
+			return priceFilters?.find((f) => f.contractAddress === contractAddress);
+		},
+		clearPriceFilters: () => {
+			setPriceFilters([]);
+		},
 		clearAllFilters: () => {
 			setShowListedOnly(false);
+			setShowPriceFilter(false);
 			setFilterOptions([]);
 			setSearchText("");
+			setPriceFilters([]);
 		}
 	}), [
 		filterOptions,
 		setFilterOptions,
 		setShowListedOnly,
-		setSearchText
+		setSearchText,
+		setShowPriceFilter,
+		priceFilters,
+		setPriceFilters
 	]);
 	return {
 		filterOptions,
 		searchText,
 		showListedOnly,
+		showPriceFilter,
+		priceFilters,
 		setFilterOptions,
 		setSearchText,
 		setShowListedOnly,
+		setShowPriceFilter,
+		setPriceFilters,
 		...helpers,
 		serialize
 	};
@@ -4446,6 +4728,65 @@ const useLoadData = () => {
 	};
 };
 
+//#endregion
+//#region src/react/ui/components/_internals/ErrorLogBox.tsx
+const ErrorLogBox = ({ title, message, error, onDismiss }) => {
+	const [showFullError, setShowFullError] = useState(false);
+	const toggleFullError = () => {
+		setShowFullError(!showFullError);
+	};
+	return /* @__PURE__ */ jsx("div", {
+		className: "relative max-h-96 w-full overflow-y-auto rounded-lg border border-red-900 bg-[#2b0000] p-3",
+		children: /* @__PURE__ */ jsxs("div", {
+			className: "flex items-start gap-3",
+			children: [
+				/* @__PURE__ */ jsx(WarningIcon, {
+					className: "absolute mt-0.5 flex-shrink-0 text-red-500",
+					size: "sm"
+				}),
+				/* @__PURE__ */ jsxs("div", {
+					className: "min-w-0 flex-1",
+					children: [/* @__PURE__ */ jsxs("div", {
+						className: "relative ml-10 flex flex-col",
+						children: [/* @__PURE__ */ jsx(Text, {
+							className: "font-bold text-red-400 text-sm",
+							children: title
+						}), /* @__PURE__ */ jsx(Text, {
+							className: "mt-1 text-red-300 text-xs",
+							children: message
+						})]
+					}), error && /* @__PURE__ */ jsxs("div", {
+						className: "mt-2",
+						children: [
+							/* @__PURE__ */ jsxs("button", {
+								onClick: toggleFullError,
+								className: "flex items-center gap-1 text-red-400 text-xs transition-colors hover:text-red-300",
+								type: "button",
+								children: [showFullError ? "Hide full error" : "Show full error", showFullError ? /* @__PURE__ */ jsx(ChevronUpIcon, { className: "h-3 w-3" }) : /* @__PURE__ */ jsx(ChevronDownIcon, { className: "h-3 w-3" })]
+							}),
+							showFullError && /* @__PURE__ */ jsx("div", { className: "mt-2 h-px bg-red-900" }),
+							showFullError && /* @__PURE__ */ jsx("div", {
+								className: "mt-2 overflow-auto rounded-md bg-red-950 p-2",
+								children: /* @__PURE__ */ jsx(Text, {
+									className: "whitespace-pre-wrap break-words font-mono text-red-100 text-xs",
+									children: JSON.stringify(error, null, 2)
+								})
+							})
+						]
+					})]
+				}),
+				onDismiss && /* @__PURE__ */ jsx("button", {
+					onClick: onDismiss,
+					className: "absolute right-4 flex-shrink-0 text-red-400 transition-colors hover:text-red-300",
+					type: "button",
+					"aria-label": "Dismiss error",
+					children: /* @__PURE__ */ jsx(CloseIcon, { className: "h-3 w-3" })
+				})
+			]
+		})
+	});
+};
+
 //#endregion
 //#region src/utils/decode/erc20.ts
 function decodeERC20Approval(calldata) {
@@ -4463,7 +4804,7 @@ function decodeERC20Approval(calldata) {
 
 //#endregion
 //#region src/react/ui/modals/BuyModal/hooks/usePaymentModalParams.ts
-const getBuyCollectableParams = async ({ chainId, collectionAddress, collectibleId, callbacks, priceCurrencyAddress, customCreditCardProviderCallback, config, address, marketplace, orderId, quantity, collectable, checkoutOptions, fee, skipNativeBalanceCheck, nativeTokenAddress, buyAnalyticsId }) => {
+const getBuyCollectableParams = async ({ chainId, collectionAddress, collectibleId, callbacks, priceCurrencyAddress, customCreditCardProviderCallback, config, address, marketplace, orderId, quantity, collectable, checkoutOptions, fee, skipNativeBalanceCheck, nativeTokenAddress, buyAnalyticsId, onRampProvider }) => {
 	const { steps: steps$2 } = await getMarketplaceClient(config).generateBuyTransaction({
 		chainId: String(chainId),
 		collectionAddress,
@@ -4506,8 +4847,8 @@ const getBuyCollectableParams = async ({ chainId, collectionAddress, collectible
 		collectionAddress,
 		recipientAddress: address,
 		creditCardProviders,
-		onSuccess: (hash) => {
-			callbacks?.onSuccess?.({ hash });
+		onSuccess: (txHash) => {
+			if (txHash) callbacks?.onSuccess?.({ hash: txHash });
 		},
 		supplementaryAnalyticsInfo: {
 			requestId: orderId,
@@ -4527,13 +4868,14 @@ const getBuyCollectableParams = async ({ chainId, collectionAddress, collectible
 			buyModalStore.send({ type: "close" });
 		} },
 		...transakContractId && { transakConfig: { contractId: transakContractId } },
+		onRampProvider,
 		successActionButtons: callbacks?.successActionButtons
 	};
 };
 const usePaymentModalParams = (args) => {
 	const { address, marketplace, collectable, checkoutOptions, priceCurrencyAddress, quantity, enabled } = args;
 	const buyModalProps = useBuyModalProps();
-	const { chainId, collectionAddress, skipNativeBalanceCheck, nativeTokenAddress } = buyModalProps;
+	const { chainId, collectionAddress, skipNativeBalanceCheck, nativeTokenAddress, onRampProvider } = buyModalProps;
 	const collectibleId = isMarketProps(buyModalProps) ? buyModalProps.collectibleId : "";
 	const orderId = isMarketProps(buyModalProps) ? buyModalProps.orderId : "";
 	const customCreditCardProviderCallback = isMarketProps(buyModalProps) ? buyModalProps.customCreditCardProviderCallback : void 0;
@@ -4573,8 +4915,10 @@ const usePaymentModalParams = (args) => {
 			customCreditCardProviderCallback,
 			skipNativeBalanceCheck,
 			nativeTokenAddress,
-			buyAnalyticsId
-		}) : skipToken
+			buyAnalyticsId,
+			onRampProvider
+		}) : skipToken,
+		retry: false
 	});
 };
 
@@ -4588,7 +4932,7 @@ const ERC721BuyModal = ({ collectable, order, address, checkoutOptions }) => {
 			quantity: 1
 		});
 	}, [quantity]);
-	const { data: paymentModalParams, isLoading: isPaymentModalParamsLoading, isError: isPaymentModalParamsError } = usePaymentModalParams({
+	const { data: paymentModalParams, isLoading: isPaymentModalParamsLoading, isError: isPaymentModalParamsError, failureReason } = usePaymentModalParams({
 		address,
 		quantity: quantity ?? void 0,
 		marketplace: order?.marketplace,
@@ -4597,6 +4941,25 @@ const ERC721BuyModal = ({ collectable, order, address, checkoutOptions }) => {
 		priceCurrencyAddress: order?.priceCurrencyAddress,
 		enabled: true
 	});
+	if (failureReason) return /* @__PURE__ */ jsx(ActionModal, {
+		isOpen: true,
+		onClose: () => {
+			buyModalStore.send({ type: "close" });
+		},
+		title: "An error occurred while purchasing",
+		children: /* @__PURE__ */ jsx(ErrorLogBox, {
+			title: failureReason.name,
+			message: failureReason.message,
+			error: failureReason
+		}),
+		ctas: [{
+			label: "Close",
+			onClick: () => {
+				buyModalStore.send({ type: "close" });
+			}
+		}],
+		chainId: order.chainId
+	});
 	if (isPaymentModalParamsLoading || !paymentModalParams) return null;
 	if (isPaymentModalParamsError) throw new Error("Failed to load payment parameters for ERC721 marketplace purchase");
 	return /* @__PURE__ */ jsx(PaymentModalOpener$2, { paymentModalParams });
@@ -4727,7 +5090,7 @@ const encodeERC721MintData = ({ to, amount, paymentToken, price, proof = DEFAULT
 		]
 	});
 };
-const getERC721SalePaymentParams = async ({ chainId, address, salesContractAddress, collectionAddress, price, currencyAddress, callbacks, customCreditCardProviderCallback, skipNativeBalanceCheck, nativeTokenAddress, checkoutProvider, quantity, successActionButtons }) => {
+const getERC721SalePaymentParams = async ({ chainId, address, salesContractAddress, collectionAddress, price, currencyAddress, callbacks, customCreditCardProviderCallback, skipNativeBalanceCheck, nativeTokenAddress, checkoutProvider, quantity, successActionButtons, onRampProvider }) => {
 	try {
 		const purchaseTransactionData = encodeERC721MintData({
 			to: address,
@@ -4750,8 +5113,8 @@ const getERC721SalePaymentParams = async ({ chainId, address, salesContractAddre
 			collectionAddress,
 			recipientAddress: address,
 			creditCardProviders,
-			onSuccess: (hash) => {
-				callbacks?.onSuccess?.({ hash });
+			onSuccess: (txHash) => {
+				if (txHash) callbacks?.onSuccess?.({ hash: txHash });
 			},
 			onError: callbacks?.onError,
 			onClose: () => {
@@ -4765,7 +5128,8 @@ const getERC721SalePaymentParams = async ({ chainId, address, salesContractAddre
 				customCreditCardProviderCallback(price.toString());
 				buyModalStore.send({ type: "close" });
 			} },
-			successActionButtons
+			successActionButtons,
+			onRampProvider
 		};
 	} catch (error) {
 		throw BuyModalErrorFactory.priceCalculation("ERC721 payment params calculation", [price.toString(), quantity.toString()], error instanceof Error ? error.message : "Unknown error");
@@ -4795,7 +5159,8 @@ const useERC721SalePaymentParams = (args) => {
 			nativeTokenAddress: void 0,
 			checkoutProvider,
 			quantity,
-			successActionButtons: buyModalProps.successActionButtons
+			successActionButtons: buyModalProps.successActionButtons,
+			onRampProvider: buyModalProps.onRampProvider
 		}) : skipToken
 	});
 };
@@ -5075,14 +5440,32 @@ const ERC1155BuyModal = ({ collectable, order, address, checkoutOptions, chainId
 	const isShop = isShopProps(modalProps);
 	const quantityDecimals = isShop ? modalProps.quantityDecimals : collectable.decimals || 0;
 	const quantityRemaining = isShop ? modalProps.quantityRemaining?.toString() : order?.quantityRemaining;
-	if (!quantity) return /* @__PURE__ */ jsx(ERC1155QuantityModal, {
+	const unlimitedSupply = isShop ? modalProps.unlimitedSupply : false;
+	useEffect(() => {
+		if (modalProps.hideQuantitySelector && !quantity) {
+			const minQuantity = quantityDecimals > 0 ? 10 ** quantityDecimals : 1;
+			const autoQuantity = unlimitedSupply ? minQuantity : Math.min(Number(quantityRemaining), minQuantity);
+			buyModalStore.send({
+				type: "setQuantity",
+				quantity: autoQuantity
+			});
+		}
+	}, [
+		modalProps.hideQuantitySelector,
+		quantity,
+		quantityDecimals,
+		unlimitedSupply,
+		quantityRemaining
+	]);
+	if (!quantity && !modalProps.hideQuantitySelector) return /* @__PURE__ */ jsx(ERC1155QuantityModal, {
 		order,
 		cardType,
 		quantityDecimals,
 		quantityRemaining,
+		unlimitedSupply,
 		chainId
 	});
-	if (!checkoutOptions) return null;
+	if (!checkoutOptions || !quantity) return null;
 	return /* @__PURE__ */ jsx(Modal$4, {
 		address,
 		quantity,
@@ -5092,7 +5475,7 @@ const ERC1155BuyModal = ({ collectable, order, address, checkoutOptions, chainId
 	});
 };
 const Modal$4 = ({ address, quantity, order, collectable, checkoutOptions }) => {
-	const { data: paymentModalParams, isLoading: isPaymentModalParamsLoading, isError: isPaymentModalParamsError } = usePaymentModalParams({
+	const { data: paymentModalParams, isLoading: isPaymentModalParamsLoading, isError: isPaymentModalParamsError, failureReason } = usePaymentModalParams({
 		address,
 		quantity,
 		marketplace: order?.marketplace,
@@ -5101,7 +5484,31 @@ const Modal$4 = ({ address, quantity, order, collectable, checkoutOptions }) =>
 		priceCurrencyAddress: order?.priceCurrencyAddress,
 		enabled: true
 	});
-	if (isPaymentModalParamsLoading || !paymentModalParams) return null;
+	if (failureReason) return /* @__PURE__ */ jsx(ActionModal, {
+		isOpen: true,
+		onClose: () => {
+			buyModalStore.send({ type: "close" });
+		},
+		title: "An error occurred while purchasing",
+		children: /* @__PURE__ */ jsx(ErrorLogBox, {
+			title: failureReason.name,
+			message: failureReason.message,
+			error: failureReason
+		}),
+		ctas: [{
+			label: "Close",
+			onClick: () => {
+				buyModalStore.send({ type: "close" });
+			}
+		}],
+		chainId: order.chainId
+	});
+	if (isPaymentModalParamsLoading || !paymentModalParams) return /* @__PURE__ */ jsx(LoadingModal, {
+		isOpen: true,
+		chainId: order.chainId,
+		onClose: () => buyModalStore.send({ type: "close" }),
+		title: "Loading checkout"
+	});
 	if (isPaymentModalParamsError) throw new Error("Failed to load payment parameters for ERC1155 marketplace purchase");
 	return /* @__PURE__ */ jsx(PaymentModalOpener, { paymentModalParams });
 };
@@ -5142,8 +5549,8 @@ const useERC1155Checkout = ({ chainId, salesContractAddress, collectionAddress,
 			}],
 			wallet: accountAddress ?? "",
 			...checkoutOptions && { checkoutOptions },
-			onSuccess: (hash) => {
-				onSuccess({ hash });
+			onSuccess: (txHash) => {
+				if (txHash) onSuccess({ hash: txHash });
 			},
 			onError: (error) => {
 				onError(error);
@@ -5163,7 +5570,8 @@ const useERC1155Checkout = ({ chainId, salesContractAddress, collectionAddress,
 				marketplaceType: "shop",
 				saleAnalyticsId
 			},
-			successActionButtons: buyModalProps.successActionButtons
+			successActionButtons: buyModalProps.successActionButtons,
+			...buyModalProps.onRampProvider && { onRampProvider: buyModalProps.onRampProvider }
 		}),
 		isEnabled: Boolean(enabled && accountAddress)
 	};
@@ -5373,8 +5781,93 @@ function Calendar({ ...props }) {
 		...props
 	});
 }
-Calendar.displayName = "Calendar";
-var calendar_default = Calendar;
+Calendar.displayName = "Calendar";
+var calendar_default = Calendar;
+
+//#endregion
+//#region src/react/ui/modals/_internal/components/calendarDropdown/TimeSelector.tsx
+function TimeSelector({ selectedDate, onTimeChange }) {
+	const minutesRef = useRef(null);
+	const [draft, setDraft] = useState(null);
+	const currentHours = getHours(selectedDate);
+	const currentMinutes = getMinutes(selectedDate);
+	const commitChange = () => {
+		if (!draft) return;
+		const now = /* @__PURE__ */ new Date();
+		const parse = (val, fallback) => {
+			const n = Number.parseInt(val, 10);
+			return Number.isNaN(n) ? fallback : n;
+		};
+		let h = clamp(parse(draft.hours, currentHours), 0, 23);
+		let m = clamp(parse(draft.minutes, currentMinutes), 0, 59);
+		if (setMinutes(setHours(selectedDate, h), m) < now) {
+			h = getHours(now);
+			m = getMinutes(now);
+		}
+		onTimeChange(h, m);
+		setDraft(null);
+	};
+	const handleKeyDown = (e, field) => {
+		if (e.key === "Enter") {
+			e.preventDefault();
+			if (field === "hours") minutesRef.current?.focus();
+			else commitChange();
+		} else if (e.key === "Escape") {
+			e.preventDefault();
+			setDraft(null);
+			e.currentTarget.blur();
+		}
+	};
+	const hours = draft?.hours ?? currentHours.toString().padStart(2, "0");
+	const minutes = draft?.minutes ?? currentMinutes.toString().padStart(2, "0");
+	return /* @__PURE__ */ jsxs("div", {
+		className: "mt-3 flex items-center gap-6 border-border-base border-t pt-3",
+		children: [/* @__PURE__ */ jsx(TimeIcon, { color: "white" }), /* @__PURE__ */ jsxs("div", {
+			className: "flex flex-1 items-center justify-between gap-2",
+			children: [
+				/* @__PURE__ */ jsx("div", {
+					className: "w-16 [&>label]:w-16",
+					children: /* @__PURE__ */ jsx(NumericInput, {
+						className: "h-9 [&>input]:text-xs",
+						name: "hours",
+						value: hours,
+						onChange: (e) => setDraft({
+							hours: e.target.value,
+							minutes
+						}),
+						onBlur: commitChange,
+						onKeyDown: (e) => handleKeyDown(e, "hours"),
+						min: 0,
+						max: 23,
+						tabIndex: 0
+					})
+				}),
+				/* @__PURE__ */ jsx(Text, {
+					className: "font-medium text-sm text-text-80",
+					children: ":"
+				}),
+				/* @__PURE__ */ jsx("div", {
+					className: "w-16 [&>label]:w-16",
+					children: /* @__PURE__ */ jsx(NumericInput, {
+						ref: minutesRef,
+						className: "h-9 [&>input]:text-xs",
+						name: "minutes",
+						value: minutes,
+						onChange: (e) => setDraft({
+							hours,
+							minutes: e.target.value
+						}),
+						onBlur: commitChange,
+						onKeyDown: (e) => handleKeyDown(e, "minutes"),
+						min: 0,
+						max: 59,
+						tabIndex: 0
+					})
+				})
+			]
+		})]
+	});
+}
 
 //#endregion
 //#region src/react/ui/modals/_internal/components/calendarDropdown/index.tsx
@@ -5394,6 +5887,11 @@ function getMatchingPreset(selectedDate) {
 }
 function CalendarDropdown({ selectedDate, setSelectedDate, onSelectPreset, isOpen, setIsOpen }) {
 	const matchingPreset = getMatchingPreset(selectedDate);
+	const handleTimeChange = (hours, minutes) => {
+		const newDate = new Date(selectedDate);
+		newDate.setHours(hours, minutes, 0, 0);
+		setSelectedDate(newDate);
+	};
 	return /* @__PURE__ */ jsxs(DropdownMenuRoot, {
 		open: isOpen,
 		onOpenChange: setIsOpen,
@@ -5403,7 +5901,7 @@ function CalendarDropdown({ selectedDate, setSelectedDate, onSelectPreset, isOpe
 				leftIcon: CalendarIcon_default,
 				className: "h-9 flex-1 rounded-sm p-2 font-medium text-xs",
 				variant: "base",
-				label: format(selectedDate, "dd/MM/yyyy HH:mm"),
+				label: format(selectedDate, "yyyy/MM/dd HH:mm"),
 				shape: "square",
 				onClick: () => setIsOpen(!isOpen)
 			})
@@ -5423,16 +5921,29 @@ function CalendarDropdown({ selectedDate, setSelectedDate, onSelectPreset, isOpe
 							},
 							variant: "text",
 							className: `w-full justify-start py-1.5 font-bold text-xs transition-colors ${isActive ? "text-text-100" : "text-text-50 hover:text-text-80"}`,
+							tabIndex: 0,
 							children: preset.label
 						}, preset.value);
 					})
-				}), /* @__PURE__ */ jsx(calendar_default, {
-					selectedDate,
-					setSelectedDate: (date) => {
-						setSelectedDate(date);
-						setIsOpen(false);
-					},
-					mode: "single"
+				}), /* @__PURE__ */ jsxs("div", {
+					className: "flex flex-col",
+					children: [/* @__PURE__ */ jsx(calendar_default, {
+						selectedDate,
+						setSelectedDate: (date) => {
+							const newDate = new Date(date);
+							const today = startOfDay(/* @__PURE__ */ new Date());
+							const selectedDay = startOfDay(newDate);
+							if (isSameDay(selectedDay, today)) setSelectedDate(endOfDay(newDate));
+							else {
+								newDate.setHours(selectedDate.getHours(), selectedDate.getMinutes(), 0, 0);
+								setSelectedDate(newDate);
+							}
+						},
+						mode: "single"
+					}), /* @__PURE__ */ jsx(TimeSelector, {
+						selectedDate,
+						onTimeChange: handleTimeChange
+					})]
 				})]
 			})
 		}) })]
@@ -5441,11 +5952,6 @@ function CalendarDropdown({ selectedDate, setSelectedDate, onSelectPreset, isOpe
 
 //#endregion
 //#region src/react/ui/modals/_internal/components/expirationDateSelect/index.tsx
-const setToEndOfDay = (date) => {
-	const endOfDay = new Date(date);
-	endOfDay.setHours(23, 59, 59, 999);
-	return endOfDay;
-};
 const PRESET_RANGES = {
 	TODAY: {
 		label: "Today",
@@ -5479,7 +5985,12 @@ const ExpirationDateSelect = function ExpirationDateSelect$1({ className, date,
 		const presetRange = Object.values(PRESET_RANGES).find((preset) => preset.value === range);
 		if (!presetRange) return;
 		const baseDate = /* @__PURE__ */ new Date();
-		const newDate = presetRange.value === "today" ? setToEndOfDay(baseDate) : addDays(baseDate, presetRange.offset);
+		const targetDate = presetRange.value === "today" ? baseDate : addDays(baseDate, presetRange.offset);
+		const newDate = presetRange.value === "today" ? endOfDay(targetDate) : (() => {
+			const preservedTimeDate = new Date(targetDate);
+			preservedTimeDate.setHours(date.getHours(), date.getMinutes(), date.getSeconds(), date.getMilliseconds());
+			return preservedTimeDate;
+		})();
 		onDateChange(newDate);
 	}
 	function handleDateValueChange(date$1) {
@@ -5739,31 +6250,424 @@ const CustomSelect = ({ items, onValueChange, defaultValue, placeholder = "Selec
 	}) })] });
 };
 
+//#endregion
+//#region src/react/ui/modals/_internal/constants/opensea-currencies.ts
+const OPENSEA_CHAIN_CURRENCIES = {
+	"1": {
+		chainId: 1,
+		openseaId: "ethereum",
+		name: "Ethereum",
+		nativeCurrency: {
+			symbol: "ETH",
+			address: "0x0000000000000000000000000000000000000000"
+		},
+		wrappedNativeCurrency: { address: "0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2" },
+		offerCurrency: {
+			symbol: "WETH",
+			address: "0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2"
+		},
+		listingCurrency: {
+			symbol: "ETH",
+			address: "0x0000000000000000000000000000000000000000"
+		}
+	},
+	"10": {
+		chainId: 10,
+		openseaId: "optimism",
+		name: "Optimism",
+		nativeCurrency: {
+			symbol: "ETH",
+			address: "0x0000000000000000000000000000000000000000"
+		},
+		wrappedNativeCurrency: { address: "0x4200000000000000000000000000000000000006" },
+		offerCurrency: {
+			symbol: "WETH",
+			address: "0x4200000000000000000000000000000000000006"
+		},
+		listingCurrency: {
+			symbol: "ETH",
+			address: "0x0000000000000000000000000000000000000000"
+		}
+	},
+	"137": {
+		chainId: 137,
+		openseaId: "matic",
+		name: "Polygon",
+		nativeCurrency: {
+			symbol: "POL",
+			address: "0x0000000000000000000000000000000000000000"
+		},
+		wrappedNativeCurrency: { address: "0x0d500b1d8e8ef31e21c99d1db9a6444d3adf1270" },
+		offerCurrency: {
+			symbol: "WETH",
+			address: "0x7ceb23fd6bc0add59e62ac25578270cff1b9f619"
+		},
+		listingCurrency: {
+			symbol: "WETH",
+			address: "0x7ceb23fd6bc0add59e62ac25578270cff1b9f619"
+		}
+	},
+	"360": {
+		chainId: 360,
+		openseaId: "shape",
+		name: "Shape",
+		nativeCurrency: {
+			symbol: "ETH",
+			address: "0x0000000000000000000000000000000000000000"
+		},
+		wrappedNativeCurrency: { address: "0x4200000000000000000000000000000000000006" },
+		offerCurrency: {
+			symbol: "WETH",
+			address: "0x4200000000000000000000000000000000000006"
+		},
+		listingCurrency: {
+			symbol: "ETH",
+			address: "0x0000000000000000000000000000000000000000"
+		}
+	},
+	"998": {
+		chainId: 998,
+		openseaId: "hyperevm",
+		name: "HyperEVM",
+		nativeCurrency: {
+			symbol: "HYPE",
+			address: "0x0000000000000000000000000000000000000000"
+		},
+		wrappedNativeCurrency: { address: "0x5555555555555555555555555555555555555555" },
+		offerCurrency: {
+			symbol: "WHYPE",
+			address: "0x5555555555555555555555555555555555555555"
+		},
+		listingCurrency: {
+			symbol: "HYPE",
+			address: "0x0000000000000000000000000000000000000000"
+		}
+	},
+	"130": {
+		chainId: 130,
+		openseaId: "unichain",
+		name: "Unichain",
+		nativeCurrency: {
+			symbol: "ETH",
+			address: "0x0000000000000000000000000000000000000000"
+		},
+		wrappedNativeCurrency: { address: "0x4200000000000000000000000000000000000006" },
+		offerCurrency: {
+			symbol: "WETH",
+			address: "0x4200000000000000000000000000000000000006"
+		},
+		listingCurrency: {
+			symbol: "ETH",
+			address: "0x0000000000000000000000000000000000000000"
+		}
+	},
+	"1329": {
+		chainId: 1329,
+		openseaId: "sei",
+		name: "Sei",
+		nativeCurrency: {
+			symbol: "SEI",
+			address: "0x0000000000000000000000000000000000000000"
+		},
+		wrappedNativeCurrency: { address: "0xe30fedd158a2e3b13e9badaeabafc5516e95e8c7" },
+		offerCurrency: {
+			symbol: "WSEI",
+			address: "0xe30fedd158a2e3b13e9badaeabafc5516e95e8c7"
+		},
+		listingCurrency: {
+			symbol: "SEI",
+			address: "0x0000000000000000000000000000000000000000"
+		}
+	},
+	"1868": {
+		chainId: 1868,
+		openseaId: "soneium",
+		name: "Soneium",
+		nativeCurrency: {
+			symbol: "ETH",
+			address: "0x0000000000000000000000000000000000000000"
+		},
+		wrappedNativeCurrency: { address: "0x4200000000000000000000000000000000000006" },
+		offerCurrency: {
+			symbol: "WETH",
+			address: "0x4200000000000000000000000000000000000006"
+		},
+		listingCurrency: {
+			symbol: "ETH",
+			address: "0x0000000000000000000000000000000000000000"
+		}
+	},
+	"2020": {
+		chainId: 2020,
+		openseaId: "ronin",
+		name: "Ronin",
+		nativeCurrency: {
+			symbol: "RON",
+			address: "0x0000000000000000000000000000000000000000"
+		},
+		wrappedNativeCurrency: { address: "0xe514d9deb7966c8be0ca922de8a064264ea6bcd4" },
+		offerCurrency: {
+			symbol: "WRON",
+			address: "0xe514d9deb7966c8be0ca922de8a064264ea6bcd4"
+		},
+		listingCurrency: {
+			symbol: "RON",
+			address: "0x0000000000000000000000000000000000000000"
+		}
+	},
+	"2741": {
+		chainId: 2741,
+		openseaId: "abstract",
+		name: "Abstract",
+		nativeCurrency: {
+			symbol: "ETH",
+			address: "0x0000000000000000000000000000000000000000"
+		},
+		wrappedNativeCurrency: { address: "0x3439153eb7af838ad19d56e1571fbd09333c2809" },
+		offerCurrency: {
+			symbol: "WETH",
+			address: "0x3439153eb7af838ad19d56e1571fbd09333c2809"
+		},
+		listingCurrency: {
+			symbol: "ETH",
+			address: "0x0000000000000000000000000000000000000000"
+		}
+	},
+	"8333": {
+		chainId: 8333,
+		openseaId: "b3",
+		name: "B3",
+		nativeCurrency: {
+			symbol: "ETH",
+			address: "0x0000000000000000000000000000000000000000"
+		},
+		wrappedNativeCurrency: { address: "0x4200000000000000000000000000000000000006" },
+		offerCurrency: {
+			symbol: "WETH",
+			address: "0x4200000000000000000000000000000000000006"
+		},
+		listingCurrency: {
+			symbol: "ETH",
+			address: "0x0000000000000000000000000000000000000000"
+		}
+	},
+	"8453": {
+		chainId: 8453,
+		openseaId: "base",
+		name: "Base",
+		nativeCurrency: {
+			symbol: "ETH",
+			address: "0x0000000000000000000000000000000000000000"
+		},
+		wrappedNativeCurrency: { address: "0x4200000000000000000000000000000000000006" },
+		offerCurrency: {
+			symbol: "WETH",
+			address: "0x4200000000000000000000000000000000000006"
+		},
+		listingCurrency: {
+			symbol: "ETH",
+			address: "0x0000000000000000000000000000000000000000"
+		}
+	},
+	"33139": {
+		chainId: 33139,
+		openseaId: "ape_chain",
+		name: "ApeChain",
+		nativeCurrency: {
+			symbol: "APE",
+			address: "0x0000000000000000000000000000000000000000"
+		},
+		wrappedNativeCurrency: { address: "0x48b62137edfa95a428d35c09e44256a739f6b557" },
+		offerCurrency: {
+			symbol: "WAPE",
+			address: "0x48b62137edfa95a428d35c09e44256a739f6b557"
+		},
+		listingCurrency: {
+			symbol: "APE",
+			address: "0x0000000000000000000000000000000000000000"
+		}
+	},
+	"42161": {
+		chainId: 42161,
+		openseaId: "arbitrum",
+		name: "Arbitrum",
+		nativeCurrency: {
+			symbol: "ETH",
+			address: "0x0000000000000000000000000000000000000000"
+		},
+		wrappedNativeCurrency: { address: "0x82af49447d8a07e3bd95bd0d56f35241523fbab1" },
+		offerCurrency: {
+			symbol: "WETH",
+			address: "0x82af49447d8a07e3bd95bd0d56f35241523fbab1"
+		},
+		listingCurrency: {
+			symbol: "ETH",
+			address: "0x0000000000000000000000000000000000000000"
+		}
+	},
+	"42170": {
+		chainId: 42170,
+		openseaId: "arbitrum_nova",
+		name: "Arbitrum Nova",
+		nativeCurrency: {
+			symbol: "ETH",
+			address: "0x0000000000000000000000000000000000000000"
+		},
+		wrappedNativeCurrency: { address: "0x722e8bdd2ce80a4422e880164f2079488e115365" },
+		offerCurrency: {
+			symbol: "WETH",
+			address: "0x722e8bdd2ce80a4422e880164f2079488e115365"
+		},
+		listingCurrency: {
+			symbol: "ETH",
+			address: "0x0000000000000000000000000000000000000000"
+		}
+	},
+	"43114": {
+		chainId: 43114,
+		openseaId: "avalanche",
+		name: "Avalanche",
+		nativeCurrency: {
+			symbol: "AVAX",
+			address: "0x0000000000000000000000000000000000000000"
+		},
+		wrappedNativeCurrency: { address: "0xb31f66aa3c1e785363f0875a1b74e27b85fd66c7" },
+		offerCurrency: {
+			symbol: "WAVAX",
+			address: "0xb31f66aa3c1e785363f0875a1b74e27b85fd66c7"
+		},
+		listingCurrency: {
+			symbol: "AVAX",
+			address: "0x0000000000000000000000000000000000000000"
+		}
+	},
+	"43419": {
+		chainId: 43419,
+		openseaId: "gunzilla",
+		name: "GUNZ",
+		nativeCurrency: {
+			symbol: "GUN",
+			address: "0x0000000000000000000000000000000000000000"
+		},
+		wrappedNativeCurrency: { address: "0x5aad7bba61d95c2c4e525a35f4062040264611f1" },
+		offerCurrency: {
+			symbol: "WGUN",
+			address: "0x5aad7bba61d95c2c4e525a35f4062040264611f1"
+		},
+		listingCurrency: {
+			symbol: "GUN",
+			address: "0x0000000000000000000000000000000000000000"
+		}
+	},
+	"50311": {
+		chainId: 50311,
+		openseaId: "somnia",
+		name: "Somnia",
+		nativeCurrency: {
+			symbol: "SOMI",
+			address: "0x0000000000000000000000000000000000000000"
+		},
+		wrappedNativeCurrency: { address: "0x046ede9564a72571df6f5e44d0405360c0f4dcab" },
+		offerCurrency: {
+			symbol: "WSOMI",
+			address: "0x046ede9564a72571df6f5e44d0405360c0f4dcab"
+		},
+		listingCurrency: {
+			symbol: "SOMI",
+			address: "0x0000000000000000000000000000000000000000"
+		}
+	},
+	"80094": {
+		chainId: 80094,
+		openseaId: "bera_chain",
+		name: "Berachain",
+		nativeCurrency: {
+			symbol: "BERA",
+			address: "0x0000000000000000000000000000000000000000"
+		},
+		wrappedNativeCurrency: { address: "0x6969696969696969696969696969696969696969" },
+		offerCurrency: {
+			symbol: "WBERA",
+			address: "0x6969696969696969696969696969696969696969"
+		},
+		listingCurrency: {
+			symbol: "BERA",
+			address: "0x0000000000000000000000000000000000000000"
+		}
+	},
+	"81457": {
+		chainId: 81457,
+		openseaId: "blast",
+		name: "Blast",
+		nativeCurrency: {
+			symbol: "ETH",
+			address: "0x0000000000000000000000000000000000000000"
+		},
+		wrappedNativeCurrency: { address: "0x4300000000000000000000000000000000000004" },
+		offerCurrency: {
+			symbol: "WETH",
+			address: "0x4300000000000000000000000000000000000004"
+		},
+		listingCurrency: {
+			symbol: "ETH",
+			address: "0x0000000000000000000000000000000000000000"
+		}
+	},
+	"7777777": {
+		chainId: 7777777,
+		openseaId: "zora",
+		name: "Zora",
+		nativeCurrency: {
+			symbol: "ETH",
+			address: "0x0000000000000000000000000000000000000000"
+		},
+		wrappedNativeCurrency: { address: "0x4200000000000000000000000000000000000006" },
+		offerCurrency: {
+			symbol: "WETH",
+			address: "0x4200000000000000000000000000000000000006"
+		},
+		listingCurrency: {
+			symbol: "ETH",
+			address: "0x0000000000000000000000000000000000000000"
+		}
+	}
+};
+function getOpenseaCurrencyForChain(chainId, modalType) {
+	const config = OPENSEA_CHAIN_CURRENCIES[chainId.toString()];
+	if (!config) return;
+	return modalType === "listing" ? config.listingCurrency : config.offerCurrency;
+}
+
 //#endregion
 //#region src/react/ui/modals/_internal/components/currencyOptionsSelect/index.tsx
-function CurrencyOptionsSelect({ chainId, collectionAddress, secondCurrencyAsDefault, selectedCurrency, onCurrencyChange, includeNativeCurrency }) {
+function CurrencyOptionsSelect({ chainId, collectionAddress, secondCurrencyAsDefault, selectedCurrency, onCurrencyChange, includeNativeCurrency, orderbookKind, modalType }) {
 	const { data: currencies, isLoading: currenciesLoading } = useMarketCurrencies({
 		chainId,
 		collectionAddress,
 		includeNativeCurrency
 	});
+	let filteredCurrencies = currencies;
+	if (currencies && orderbookKind === OrderbookKind.opensea && modalType) {
+		const openseaCurrency = getOpenseaCurrencyForChain(chainId, modalType);
+		if (openseaCurrency) filteredCurrencies = currencies.filter((currency) => compareAddress(currency.contractAddress, openseaCurrency.address));
+	}
 	useEffect(() => {
-		if (currencies && currencies.length > 0 && !selectedCurrency?.contractAddress) if (secondCurrencyAsDefault) onCurrencyChange(currencies[1]);
-		else onCurrencyChange(currencies[0]);
+		if (filteredCurrencies && filteredCurrencies.length > 0 && !selectedCurrency?.contractAddress) if (secondCurrencyAsDefault && filteredCurrencies.length > 1) onCurrencyChange(filteredCurrencies[1]);
+		else onCurrencyChange(filteredCurrencies[0]);
 	}, [
-		currencies,
+		filteredCurrencies,
 		selectedCurrency?.contractAddress,
 		secondCurrencyAsDefault,
 		onCurrencyChange
 	]);
-	if (!currencies || currenciesLoading || !selectedCurrency?.symbol) return /* @__PURE__ */ jsx(Skeleton, { className: "mr-3 h-7 w-20 rounded-2xl" });
-	const options = currencies.map((currency) => ({
+	if (!filteredCurrencies || currenciesLoading || !selectedCurrency?.symbol) return /* @__PURE__ */ jsx(Skeleton, { className: "mr-3 h-7 w-20 rounded-2xl" });
+	const options = filteredCurrencies.map((currency) => ({
 		label: currency.symbol,
 		value: currency.contractAddress,
 		content: currency.symbol
 	}));
 	const onChange = (value) => {
-		const selectedCurrency$1 = currencies.find((currency) => currency.contractAddress === value);
+		const selectedCurrency$1 = filteredCurrencies.find((currency) => currency.contractAddress === value);
 		if (selectedCurrency$1) onCurrencyChange(selectedCurrency$1);
 	};
 	return /* @__PURE__ */ jsx(CustomSelect, {
@@ -5780,7 +6684,7 @@ var currencyOptionsSelect_default = CurrencyOptionsSelect;
 
 //#endregion
 //#region src/react/ui/modals/_internal/components/priceInput/index.tsx
-function PriceInput({ chainId, collectionAddress, price, onPriceChange, onCurrencyChange, checkBalance, secondCurrencyAsDefault, includeNativeCurrency, disabled }) {
+function PriceInput({ chainId, collectionAddress, price, onPriceChange, onCurrencyChange, checkBalance, secondCurrencyAsDefault, includeNativeCurrency, disabled, orderbookKind, setOpenseaLowestPriceCriteriaMet, modalType }) {
 	const { address: accountAddress } = useAccount();
 	const inputRef = useRef(null);
 	const currency = price?.currency;
@@ -5790,6 +6694,12 @@ function PriceInput({ chainId, collectionAddress, price, onPriceChange, onCurren
 	const handleCurrencyChange = (newCurrency) => {
 		if (price && onCurrencyChange) onCurrencyChange(newCurrency);
 	};
+	const { data: conversion, isLoading: isConversionLoading } = useConvertPriceToUSD({
+		chainId,
+		currencyAddress,
+		amountRaw: priceAmountRaw,
+		query: { enabled: orderbookKind === OrderbookKind.opensea && !!currencyAddress && !!priceAmountRaw && !!setOpenseaLowestPriceCriteriaMet }
+	});
 	useEffect(() => {
 		if (inputRef.current) inputRef.current.focus();
 	}, []);
@@ -5799,7 +6709,9 @@ function PriceInput({ chainId, collectionAddress, price, onPriceChange, onCurren
 		userAddress: accountAddress
 	});
 	const balanceError = !!checkBalance?.enabled && !!isBalanceSuccess && !!priceAmountRaw && !!currencyDecimals && BigInt(priceAmountRaw) > BigInt(balance?.value || 0n);
+	const openseaLowestPriceCriteriaMet = orderbookKind === OrderbookKind.opensea && !!conversion?.usdAmount && conversion.usdAmount >= .01;
 	if (checkBalance?.enabled) checkBalance.callback(balanceError);
+	if (setOpenseaLowestPriceCriteriaMet) setOpenseaLowestPriceCriteriaMet(openseaLowestPriceCriteriaMet);
 	const [value, setValue] = useState("0");
 	const prevCurrencyDecimals = useRef(currencyDecimals);
 	useEffect(() => {
@@ -5865,7 +6777,9 @@ function PriceInput({ chainId, collectionAddress, price, onPriceChange, onCurren
 						collectionAddress,
 						chainId,
 						secondCurrencyAsDefault,
-						includeNativeCurrency
+						includeNativeCurrency,
+						orderbookKind,
+						modalType
 					}),
 					value,
 					onChange: handleChange
@@ -5875,6 +6789,11 @@ function PriceInput({ chainId, collectionAddress, price, onPriceChange, onCurren
 				className: "-bottom-5 absolute font-body font-medium text-xs",
 				color: "negative",
 				children: "Insufficient balance"
+			}),
+			!balanceError && priceAmountRaw !== "0" && !openseaLowestPriceCriteriaMet && orderbookKind === OrderbookKind.opensea && !isConversionLoading && modalType === "offer" && /* @__PURE__ */ jsx(Text, {
+				className: "-bottom-5 absolute font-body font-medium text-xs",
+				color: "negative",
+				children: "Lowest price must be at least $0.01"
 			})
 		]
 	});
@@ -6181,14 +7100,36 @@ function TransactionDetails({ collectibleId, collectionAddress, chainId, include
 		collectionAddress,
 		collectibleId
 	});
+	const [overflow, setOverflow] = useState({
+		status: false,
+		amount: "0"
+	});
 	const priceLoading = !price || marketplaceConfigLoading || royaltyLoading;
-	let formattedAmount = "0";
-	if (price) {
+	const [formattedAmount, setFormattedAmount] = useState("0");
+	useEffect(() => {
+		if (!price || royaltyLoading || marketplaceConfigLoading) return;
 		const fees = [];
 		if (royalty !== null) fees.push(Number(royalty.percentage));
 		if (marketplaceFeePercentage > 0) fees.push(marketplaceFeePercentage);
-		formattedAmount = calculateEarningsAfterFees(BigInt(price.amountRaw), price.currency.decimals, fees);
-	}
+		const newFormattedAmount = calculateEarningsAfterFees(BigInt(price.amountRaw), price.currency.decimals, fees);
+		setFormattedAmount(newFormattedAmount);
+	}, [
+		price,
+		royalty,
+		marketplaceFeePercentage,
+		royaltyLoading,
+		marketplaceConfigLoading
+	]);
+	useEffect(() => {
+		if (formattedAmount.length > 15) setOverflow((prev) => prev.status ? prev : {
+			status: true,
+			amount: formattedAmount.slice(0, 15)
+		});
+		else setOverflow({
+			status: false,
+			amount: formattedAmount
+		});
+	}, [formattedAmount]);
 	return /* @__PURE__ */ jsxs("div", {
 		className: "flex w-full items-center justify-between",
 		children: [/* @__PURE__ */ jsx(Text, {
@@ -6200,14 +7141,36 @@ function TransactionDetails({ collectibleId, collectionAddress, chainId, include
 			children: [/* @__PURE__ */ jsx(Image, {
 				className: "h-3 w-3",
 				src: currencyImageUrl
-			}), priceLoading ? /* @__PURE__ */ jsx(Skeleton, { className: "h-4 w-24 animate-shimmer" }) : /* @__PURE__ */ jsxs(Text, {
+			}), priceLoading ? /* @__PURE__ */ jsx(Skeleton, { className: "h-4 w-24 animate-shimmer" }) : /* @__PURE__ */ jsx(Text, {
 				className: "font-body font-medium text-xs",
 				color: "text100",
-				children: [
-					showPlaceholderPrice ? "0" : formattedAmount,
-					" ",
-					price.currency.symbol
-				]
+				children: showPlaceholderPrice ? /* @__PURE__ */ jsxs(Text, {
+					className: "font-body font-medium text-xs",
+					color: "text100",
+					children: ["0 ", price.currency.symbol]
+				}) : overflow.status ? /* @__PURE__ */ jsx(Tooltip, {
+					message: formattedAmount + " " + price.currency.symbol,
+					children: /* @__PURE__ */ jsxs("div", {
+						className: "flex items-center",
+						children: [/* @__PURE__ */ jsx(ChevronRightIcon, { className: "h-3 w-3 text-text-100" }), /* @__PURE__ */ jsxs(Text, {
+							className: "font-body font-medium text-xs",
+							color: "text100",
+							children: [
+								overflow.amount,
+								" ",
+								price.currency.symbol
+							]
+						})]
+					})
+				}) : /* @__PURE__ */ jsxs(Text, {
+					className: "font-body font-medium text-xs",
+					color: "text100",
+					children: [
+						formattedAmount,
+						" ",
+						price.currency.symbol
+					]
+				})
 			})]
 		})]
 	});
@@ -6250,7 +7213,7 @@ const useGetTokenApprovalData$2 = (params) => {
 		expiry: String(Number(dateToUnixTime(/* @__PURE__ */ new Date())) + ONE_DAY_IN_SECONDS$1)
 	};
 	const isEnabled = address && (params.query?.enabled ?? true) && !!params.currencyAddress;
-	const { data, isLoading, isSuccess } = useQuery({
+	const { data, isLoading, isSuccess, isError, error } = useQuery({
 		queryKey: [
 			"token-approval-data",
 			params,
@@ -6264,7 +7227,8 @@ const useGetTokenApprovalData$2 = (params) => {
 				walletType: walletKind,
 				contractType: params.contractType,
 				orderbook: params.orderbook,
-				listing
+				listing,
+				additionalFees: []
 			};
 			const tokenApprovalStep = (await marketplaceClient.generateListingTransaction(args).then((resp) => resp.steps)).find((step) => step.id === StepType.tokenApproval);
 			if (!tokenApprovalStep) return { step: null };
@@ -6274,7 +7238,9 @@ const useGetTokenApprovalData$2 = (params) => {
 	return {
 		data,
 		isLoading,
-		isSuccess
+		isSuccess,
+		isError,
+		error
 	};
 };
 
@@ -6324,7 +7290,8 @@ const useTransactionSteps$2 = ({ listingInput, chainId, collectionAddress, order
 				listing: {
 					...listingInput.listing,
 					expiry: /* @__PURE__ */ new Date(Number(listingInput.listing.expiry) * 1e3)
-				}
+				},
+				additionalFees: []
 			});
 		} catch (error) {
 			if (callbacks?.onError) callbacks.onError(error);
@@ -6440,7 +7407,7 @@ const useCreateListing = ({ listingInput, chainId, collectionAddress, orderbookK
 	const { data: marketplaceConfig, isLoading: marketplaceIsLoading } = useMarketplaceConfig();
 	const collectionConfig = marketplaceConfig?.market.collections.find((c) => compareAddress(c.itemsAddress, collectionAddress));
 	orderbookKind = orderbookKind ?? collectionConfig?.destinationMarketplace ?? OrderbookKind.sequence_marketplace_v2;
-	const { data: tokenApproval, isLoading: tokenApprovalIsLoading } = useGetTokenApprovalData$2({
+	const { data: tokenApproval, isLoading: tokenApprovalIsLoading, isError, error } = useGetTokenApprovalData$2({
 		chainId,
 		tokenId: listingInput.listing.tokenId,
 		collectionAddress,
@@ -6466,7 +7433,9 @@ const useCreateListing = ({ listingInput, chainId, collectionAddress, orderbookK
 		executeApproval,
 		createListing,
 		tokenApprovalStepExists: tokenApproval?.step !== null,
-		tokenApprovalIsLoading
+		tokenApprovalIsLoading,
+		isError,
+		error
 	};
 };
 
@@ -6542,7 +7511,11 @@ const CreateListingModal = () => {
 	});
 };
 const Modal$3 = observer(() => {
-	const { collectionAddress, chainId, listingPrice: listingPrice$1, collectibleId, orderbookKind, callbacks, listingIsBeingProcessed } = createListingModal$.get();
+	const { collectionAddress, chainId, listingPrice: listingPrice$1, collectibleId, orderbookKind: orderbookKindProp, callbacks, listingIsBeingProcessed } = createListingModal$.get();
+	const { data: marketplaceConfig } = useMarketplaceConfig();
+	const [error, setError] = useState(void 0);
+	const collectionConfig = marketplaceConfig?.market.collections.find((c) => c.itemsAddress === collectionAddress);
+	const orderbookKind = orderbookKindProp ?? collectionConfig?.destinationMarketplace;
 	const steps$ = createListingModal$.steps;
 	const { isWaaS } = useConnectorMetadata();
 	const { isVisible: feeOptionsVisible, selectedFeeOption } = useSelectWaasFeeOptionsStore();
@@ -6574,7 +7547,7 @@ const Modal$3 = observer(() => {
 		userAddress: address ?? void 0
 	});
 	const balanceWithDecimals = balance?.balance ? dn.toNumber(dn.from([BigInt(balance.balance), collectible?.decimals || 0])) : 0;
-	const { isLoading, executeApproval, createListing, tokenApprovalIsLoading } = useCreateListing({
+	const { isLoading, executeApproval, createListing, tokenApprovalIsLoading, isError: tokenApprovalIsError } = useCreateListing({
 		listingInput: {
 			contractType: collection?.type,
 			listing: {
@@ -6592,7 +7565,7 @@ const Modal$3 = observer(() => {
 		closeMainModal: () => createListingModal$.close(),
 		steps$
 	});
-	if (collectableIsError || collectionIsError || currenciesIsError) return /* @__PURE__ */ jsx(ErrorModal, {
+	if (collectableIsError || collectionIsError || currenciesIsError || tokenApprovalIsError) return /* @__PURE__ */ jsx(ErrorModal, {
 		isOpen: createListingModal$.isOpen.get(),
 		chainId: Number(chainId),
 		onClose: createListingModal$.close,
@@ -6610,17 +7583,24 @@ const Modal$3 = observer(() => {
 		try {
 			if (isWaaS) selectWaasFeeOptionsStore.send({ type: "show" });
 			await createListing({ isTransactionExecuting: !!isWaaS });
-		} catch (error) {
-			console.error("Create listing failed:", error);
+		} catch (error$1) {
+			console.error("Create listing failed:", error$1);
+			setError(error$1);
 		} finally {
 			createListingModal$.listingIsBeingProcessed.set(false);
 			steps$.transaction.isExecuting.set(false);
 		}
 	};
+	const handleApproveToken = async () => {
+		await executeApproval().catch((error$1) => {
+			console.error("Approve TOKEN failed:", error$1);
+			setError(error$1);
+		});
+	};
 	const listCtaLabel = getActionLabel("List item for sale");
 	const ctas = [{
 		label: "Approve TOKEN",
-		onClick: async () => await executeApproval(),
+		onClick: handleApproveToken,
 		hidden: !steps$.approval.exist.get(),
 		pending: steps$?.approval.isExecuting.get(),
 		variant: "glass",
@@ -6663,7 +7643,9 @@ const Modal$3 = observer(() => {
 					onCurrencyChange: (newCurrency) => {
 						createListingModal$.listingPrice.currency.set(newCurrency);
 					},
-					disabled: shouldHideListButton
+					disabled: shouldHideListButton,
+					orderbookKind,
+					modalType: "listing"
 				}), listingPrice$1.amountRaw !== "0" && /* @__PURE__ */ jsx(FloorPriceText, {
 					tokenId: collectibleId,
 					chainId,
@@ -6700,6 +7682,11 @@ const Modal$3 = observer(() => {
 					steps$.transaction.isExecuting.set(false);
 				},
 				titleOnConfirm: "Processing listing..."
+			}),
+			error && /* @__PURE__ */ jsx(ErrorLogBox, {
+				title: "An error occurred while listing",
+				message: "Please try again",
+				error
 			})
 		]
 	});
@@ -6736,7 +7723,7 @@ const useGetTokenApprovalData$1 = (params) => {
 		expiry: String(Number(dateToUnixTime(/* @__PURE__ */ new Date())) + ONE_DAY_IN_SECONDS)
 	};
 	const isEnabled = address && params.query?.enabled !== false;
-	const { data, isLoading, isSuccess } = useQuery({
+	const { data, isLoading, isSuccess, isError, error } = useQuery({
 		queryKey: ["token-approval-data", params.currencyAddress],
 		queryFn: isEnabled ? async () => {
 			const args = {
@@ -6746,7 +7733,8 @@ const useGetTokenApprovalData$1 = (params) => {
 				walletType: walletKind,
 				contractType: params.contractType,
 				orderbook: params.orderbook,
-				offer
+				offer,
+				additionalFees: []
 			};
 			const tokenApprovalStep = (await marketplaceClient.generateOfferTransaction(args).then((resp) => resp.steps)).find((step) => step.id === StepType.tokenApproval);
 			if (!tokenApprovalStep) return { step: null };
@@ -6757,7 +7745,9 @@ const useGetTokenApprovalData$1 = (params) => {
 	return {
 		data,
 		isLoading,
-		isSuccess
+		isSuccess,
+		isError,
+		error
 	};
 };
 
@@ -6793,7 +7783,8 @@ const useTransactionSteps$1 = ({ offerInput, chainId, collectionAddress, orderbo
 				offer: {
 					...offerInput.offer,
 					expiry: /* @__PURE__ */ new Date(Number(offerInput.offer.expiry) * 1e3)
-				}
+				},
+				additionalFees: []
 			});
 		} catch (error) {
 			if (callbacks?.onError) callbacks.onError(error);
@@ -6898,17 +7889,13 @@ const useTransactionSteps$1 = ({ offerInput, chainId, collectionAddress, orderbo
 //#endregion
 //#region src/react/ui/modals/MakeOfferModal/hooks/useMakeOffer.tsx
 const useMakeOffer = ({ offerInput, chainId, collectionAddress, orderbookKind, callbacks, closeMainModal, steps$ }) => {
-	const { data: marketplaceConfig, isLoading: marketplaceIsLoading } = useMarketplaceConfig();
-	const collectionConfig = marketplaceConfig?.market.collections.find((c) => c.itemsAddress === collectionAddress);
-	orderbookKind = orderbookKind ?? collectionConfig?.destinationMarketplace ?? OrderbookKind.sequence_marketplace_v2;
-	const { data: tokenApproval, isLoading: tokenApprovalIsLoading } = useGetTokenApprovalData$1({
+	const { data: tokenApproval, isLoading: tokenApprovalIsLoading, isError, error } = useGetTokenApprovalData$1({
 		chainId,
 		tokenId: offerInput.offer.tokenId,
 		collectionAddress,
 		currencyAddress: offerInput.offer.currencyAddress,
 		contractType: offerInput.contractType,
-		orderbook: orderbookKind,
-		query: { enabled: !marketplaceIsLoading }
+		orderbook: orderbookKind || OrderbookKind.sequence_marketplace_v2
 	});
 	useEffect(() => {
 		if (!tokenApprovalIsLoading) steps$.approval.exist.set(!!tokenApproval?.step);
@@ -6927,7 +7914,9 @@ const useMakeOffer = ({ offerInput, chainId, collectionAddress, orderbookKind, c
 		executeApproval,
 		makeOffer,
 		tokenApprovalStepExists: tokenApproval?.step !== null,
-		tokenApprovalIsLoading
+		tokenApprovalIsLoading,
+		isError,
+		error
 	};
 };
 
@@ -7001,9 +7990,14 @@ const MakeOfferModal = () => {
 	});
 };
 const Modal$2 = observer(() => {
-	const { collectionAddress, chainId, offerPrice: offerPrice$1, offerPriceChanged, invalidQuantity, collectibleId, orderbookKind, callbacks } = makeOfferModal$.get();
+	const { collectionAddress, chainId, offerPrice: offerPrice$1, offerPriceChanged, invalidQuantity, collectibleId, orderbookKind: orderbookKindProp, callbacks } = makeOfferModal$.get();
+	const { data: marketplaceConfig } = useMarketplaceConfig();
+	const [error, setError] = useState(void 0);
+	const collectionConfig = marketplaceConfig?.market.collections.find((c) => c.itemsAddress === collectionAddress);
+	const orderbookKind = orderbookKindProp ?? collectionConfig?.destinationMarketplace;
 	const steps$ = makeOfferModal$.steps;
 	const [insufficientBalance, setInsufficientBalance] = useState(false);
+	const [openseaLowestPriceCriteriaMet, setOpenseaLowestPriceCriteriaMet] = useState(true);
 	const { data: collectible, isLoading: collectableIsLoading, isError: collectableIsError } = useCollectible({
 		chainId,
 		collectionAddress,
@@ -7026,7 +8020,7 @@ const Modal$2 = observer(() => {
 		includeNativeCurrency: false
 	});
 	const modalLoading = collectableIsLoading || collectionIsLoading || currenciesLoading;
-	const { isLoading, executeApproval, makeOffer } = useMakeOffer({
+	const { isLoading, executeApproval, makeOffer, isError: approvalIsError } = useMakeOffer({
 		offerInput: {
 			contractType: collection?.type,
 			offer: {
@@ -7039,8 +8033,8 @@ const Modal$2 = observer(() => {
 		},
 		chainId,
 		collectionAddress,
-		orderbookKind,
 		callbacks,
+		orderbookKind,
 		closeMainModal: () => makeOfferModal$.close(),
 		steps$
 	});
@@ -7051,7 +8045,7 @@ const Modal$2 = observer(() => {
 		collectionAddress,
 		filter: { currencies: [offerPrice$1.currency.contractAddress] }
 	});
-	if (collectableIsError || collectionIsError || currenciesIsError) return /* @__PURE__ */ jsx(ErrorModal, {
+	if (collectableIsError || collectionIsError || currenciesIsError || approvalIsError) return /* @__PURE__ */ jsx(ErrorModal, {
 		isOpen: makeOfferModal$.isOpen.get(),
 		chainId: Number(chainId),
 		onClose: makeOfferModal$.close,
@@ -7069,26 +8063,33 @@ const Modal$2 = observer(() => {
 		try {
 			if (isWaaS) selectWaasFeeOptionsStore.send({ type: "show" });
 			await makeOffer({ isTransactionExecuting: isWaaS ? getNetwork(Number(chainId)).type !== NetworkType.TESTNET : false });
-		} catch (error) {
-			console.error("Make offer failed:", error);
+		} catch (error$1) {
+			console.error("Make offer failed:", error$1);
+			setError(error$1);
 		} finally {
 			makeOfferModal$.offerIsBeingProcessed.set(false);
 			steps$.transaction.isExecuting.set(false);
 		}
 	};
+	const handleApproveToken = async () => {
+		await executeApproval().catch((error$1) => {
+			console.error("Approve TOKEN failed:", error$1);
+			setError(error$1);
+		});
+	};
 	const offerCtaLabel = getActionLabel("Make offer");
 	const ctas = [{
 		label: "Approve TOKEN",
-		onClick: async () => await executeApproval(),
+		onClick: handleApproveToken,
 		hidden: !steps$.approval.exist.get(),
 		pending: steps$.approval.isExecuting.get(),
 		variant: "glass",
-		disabled: invalidQuantity || isLoading || insufficientBalance || offerPrice$1.amountRaw === "0" || !offerPriceChanged
+		disabled: invalidQuantity || isLoading || insufficientBalance || offerPrice$1.amountRaw === "0" || !offerPriceChanged || orderbookKind === OrderbookKind.opensea && !openseaLowestPriceCriteriaMet
 	}, {
 		label: offerCtaLabel,
 		onClick: () => handleMakeOffer(),
 		pending: steps$?.transaction.isExecuting.get() || makeOfferModal$.offerIsBeingProcessed.get(),
-		disabled: steps$.approval.isExecuting.get() || steps$.approval.exist.get() || offerPrice$1.amountRaw === "0" || insufficientBalance || isLoading || invalidQuantity
+		disabled: steps$.approval.isExecuting.get() || steps$.approval.exist.get() || offerPrice$1.amountRaw === "0" || insufficientBalance || isLoading || invalidQuantity || orderbookKind === OrderbookKind.opensea && !openseaLowestPriceCriteriaMet
 	}];
 	return /* @__PURE__ */ jsxs(ActionModal, {
 		isOpen: makeOfferModal$.isOpen.get(),
@@ -7126,6 +8127,9 @@ const Modal$2 = observer(() => {
 					enabled: true,
 					callback: (state) => setInsufficientBalance(state)
 				},
+				setOpenseaLowestPriceCriteriaMet: (state) => setOpenseaLowestPriceCriteriaMet(state),
+				orderbookKind,
+				modalType: "offer",
 				disabled: shouldHideOfferButton
 			}),
 			collection?.type === ContractType.ERC1155 && /* @__PURE__ */ jsx(QuantityInput, {
@@ -7165,6 +8169,11 @@ const Modal$2 = observer(() => {
 					steps$.transaction.isExecuting.set(false);
 				},
 				titleOnConfirm: "Processing offer..."
+			}),
+			error && /* @__PURE__ */ jsx(ErrorLogBox, {
+				title: "An error occurred while making an offer",
+				message: "Please try again",
+				error
 			})
 		]
 	});
@@ -7207,7 +8216,7 @@ const useGetTokenApprovalData = (params) => {
 		chainId: Number(params.chainId),
 		collectionAddress: params.collectionAddress
 	});
-	const { data, isLoading, isSuccess } = useQuery({
+	const { data, isLoading, isSuccess, isError, error } = useQuery({
 		queryKey: ["token-approval-data", params.ordersData],
 		queryFn: address ? async () => {
 			const args = {
@@ -7231,7 +8240,9 @@ const useGetTokenApprovalData = (params) => {
 	return {
 		data,
 		isLoading,
-		isSuccess
+		isSuccess,
+		isError,
+		error
 	};
 };
 
@@ -7378,7 +8389,7 @@ const useTransactionSteps = ({ collectibleId, chainId, collectionAddress, market
 //#endregion
 //#region src/react/ui/modals/SellModal/hooks/useSell.tsx
 const useSell = ({ collectibleId, chainId, collectionAddress, marketplace, ordersData, callbacks, closeMainModal, steps$ }) => {
-	const { data: tokenApproval, isLoading: tokenApprovalIsLoading } = useGetTokenApprovalData({
+	const { data: tokenApproval, isLoading: tokenApprovalIsLoading, isError, error } = useGetTokenApprovalData({
 		chainId,
 		collectionAddress,
 		ordersData,
@@ -7402,7 +8413,9 @@ const useSell = ({ collectibleId, chainId, collectionAddress, marketplace, order
 		executeApproval,
 		sell,
 		tokenApprovalStepExists: tokenApproval?.step !== null,
-		tokenApprovalIsLoading
+		tokenApprovalIsLoading,
+		isError,
+		error
 	};
 };
 
@@ -7421,6 +8434,7 @@ const Modal$1 = observer(() => {
 		chainId,
 		collectionAddress
 	});
+	const [error, setError] = useState(void 0);
 	const { data: collection, isLoading: collectionLoading, isError: collectionError } = useCollection({
 		chainId,
 		collectionAddress
@@ -7438,7 +8452,7 @@ const Modal$1 = observer(() => {
 		feeOptionsVisible,
 		selectedFeeOption
 	});
-	const { isLoading, executeApproval, sell } = useSell({
+	const { isLoading, executeApproval, sell, isError } = useSell({
 		collectionAddress,
 		chainId,
 		collectibleId: tokenId,
@@ -7454,7 +8468,7 @@ const Modal$1 = observer(() => {
 		steps$
 	});
 	const modalLoading = collectionLoading || currencyLoading;
-	if ((collectionError || order === void 0 || currencyError) && !modalLoading) return /* @__PURE__ */ jsx(ErrorModal, {
+	if ((collectionError || order === void 0 || currencyError || isError) && !modalLoading) return /* @__PURE__ */ jsx(ErrorModal, {
 		isOpen: sellModal$.isOpen.get(),
 		chainId: Number(chainId),
 		onClose: sellModal$.close,
@@ -7465,17 +8479,23 @@ const Modal$1 = observer(() => {
 		try {
 			if (isWaaS) selectWaasFeeOptionsStore.send({ type: "show" });
 			await sell({ isTransactionExecuting: isWaaS ? !isTestnet : false });
-		} catch (error) {
-			console.error("Sell failed:", error);
+		} catch (error$1) {
+			console.error("Sell failed:", error$1);
 		} finally {
 			sellModal$.sellIsBeingProcessed.set(false);
 			steps$.transaction.isExecuting.set(false);
 		}
 	};
+	const handleApproveToken = async () => {
+		await executeApproval().catch((error$1) => {
+			console.error("Approve TOKEN failed:", error$1);
+			setError(error$1);
+		});
+	};
 	const sellCtaLabel = isProcessing ? isWaaS && !isTestnet ? "Loading fee options" : "Accept" : "Accept";
 	const ctas = [{
 		label: "Approve TOKEN",
-		onClick: async () => await executeApproval(),
+		onClick: handleApproveToken,
 		hidden: !steps$.approval.exist.get(),
 		pending: steps$.approval.isExecuting.get(),
 		variant: "glass",
@@ -7530,6 +8550,11 @@ const Modal$1 = observer(() => {
 					steps$.transaction.isExecuting.set(false);
 				},
 				titleOnConfirm: "Accepting offer..."
+			}),
+			error && /* @__PURE__ */ jsx(ErrorLogBox, {
+				title: "An error occurred while selling",
+				message: error.message,
+				error
 			})
 		]
 	});
@@ -8158,7 +9183,12 @@ const styles = String.raw`/* Modified Tailwind CSS, to avoid issues with shadow
   :root, :host {
     --font-sans: ui-sans-serif, system-ui, sans-serif, "Apple Color Emoji",
       "Segoe UI Emoji", "Segoe UI Symbol", "Noto Color Emoji";
+    --color-red-100: oklch(93.6% 0.032 17.717);
+    --color-red-300: oklch(80.8% 0.114 19.571);
+    --color-red-400: oklch(70.4% 0.191 22.216);
     --color-red-500: oklch(63.7% 0.237 25.331);
+    --color-red-900: oklch(39.6% 0.141 25.723);
+    --color-red-950: oklch(25.8% 0.092 26.042);
     --color-green-500: oklch(72.3% 0.219 149.579);
     --color-blue-500: oklch(62.3% 0.214 259.815);
     --color-indigo-400: oklch(67.3% 0.182 276.935);
@@ -8576,6 +9606,9 @@ const styles = String.raw`/* Modified Tailwind CSS, to avoid issues with shadow
   .ml-5 {
     margin-left: calc(var(--spacing) * 5);
   }
+  .ml-10 {
+    margin-left: calc(var(--spacing) * 10);
+  }
   .block {
     display: block;
   }
@@ -8699,6 +9732,9 @@ const styles = String.raw`/* Modified Tailwind CSS, to avoid issues with shadow
   .h-px {
     height: 1px;
   }
+  .max-h-96 {
+    max-height: calc(var(--spacing) * 96);
+  }
   .max-h-\[240px\] {
     max-height: 240px;
   }
@@ -8855,6 +9891,9 @@ const styles = String.raw`/* Modified Tailwind CSS, to avoid issues with shadow
   .flex-shrink {
     flex-shrink: 1;
   }
+  .flex-shrink-0 {
+    flex-shrink: 0;
+  }
   .shrink-0 {
     flex-shrink: 0;
   }
@@ -9111,6 +10150,10 @@ const styles = String.raw`/* Modified Tailwind CSS, to avoid issues with shadow
     border-style: var(--tw-border-style);
     border-width: 2px;
   }
+  .border-t {
+    border-top-style: var(--tw-border-style);
+    border-top-width: 1px;
+  }
   .border-b-2 {
     border-bottom-style: var(--tw-border-style);
     border-bottom-width: 2px;
@@ -9142,6 +10185,9 @@ const styles = String.raw`/* Modified Tailwind CSS, to avoid issues with shadow
   .border-border-normal {
     border-color: var(--seq-color-border-normal);
   }
+  .border-red-900 {
+    border-color: var(--color-red-900);
+  }
   .border-transparent {
     border-color: transparent;
   }
@@ -9154,6 +10200,9 @@ const styles = String.raw`/* Modified Tailwind CSS, to avoid issues with shadow
   .border-b-transparent {
     border-bottom-color: transparent;
   }
+  .bg-\[\#2b0000\] {
+    background-color: #2b0000;
+  }
   .bg-\[\#35a554\] {
     background-color: #35a554;
   }
@@ -9226,6 +10275,12 @@ const styles = String.raw`/* Modified Tailwind CSS, to avoid issues with shadow
   .bg-red-500 {
     background-color: var(--color-red-500);
   }
+  .bg-red-900 {
+    background-color: var(--color-red-900);
+  }
+  .bg-red-950 {
+    background-color: var(--color-red-950);
+  }
   .bg-surface-neutral {
     background-color: var(--color-surface-neutral);
   }
@@ -9535,12 +10590,18 @@ const styles = String.raw`/* Modified Tailwind CSS, to avoid issues with shadow
     --tw-tracking: var(--tracking-widest);
     letter-spacing: var(--tracking-widest);
   }
+  .break-words {
+    overflow-wrap: break-word;
+  }
   .text-ellipsis {
     text-overflow: ellipsis;
   }
   .whitespace-nowrap {
     white-space: nowrap;
   }
+  .whitespace-pre-wrap {
+    white-space: pre-wrap;
+  }
   .text-background-raised {
     color: var(--seq-color-background-raised);
   }
@@ -9577,6 +10638,15 @@ const styles = String.raw`/* Modified Tailwind CSS, to avoid issues with shadow
   .text-primary {
     color: var(--seq-color-primary);
   }
+  .text-red-100 {
+    color: var(--color-red-100);
+  }
+  .text-red-300 {
+    color: var(--color-red-300);
+  }
+  .text-red-400 {
+    color: var(--color-red-400);
+  }
   .text-red-500 {
     color: var(--color-red-500);
   }
@@ -10149,6 +11219,13 @@ const styles = String.raw`/* Modified Tailwind CSS, to avoid issues with shadow
       }
     }
   }
+  .hover\:text-red-300 {
+    &:hover {
+      @media (hover: hover) {
+        color: var(--color-red-300);
+      }
+    }
+  }
   .hover\:text-text-80 {
     &:hover {
       @media (hover: hover) {
@@ -10540,6 +11617,11 @@ const styles = String.raw`/* Modified Tailwind CSS, to avoid issues with shadow
       display: flex;
     }
   }
+  .\[\&\>label\]\:w-16 {
+    &>label {
+      width: calc(var(--spacing) * 16);
+    }
+  }
   .\[\&\>label\]\:w-full {
     &>label {
       width: 100%;
@@ -11128,6 +12210,103 @@ const styles = String.raw`/* Modified Tailwind CSS, to avoid issues with shadow
 .rdp-caption_before_exit {
   animation: rdp-fade_out var(--rdp-animation_duration) var(--rdp-animation_timing) forwards;
 }
+.rdp-root {
+  width: 100% !important;
+  padding: 0 !important;
+  user-select: none;
+}
+.rdp-nav {
+  position: absolute;
+  width: 100%;
+  height: fit-content !important;
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+}
+.rdp-caption_label {
+  color: var(--color-text-100) !important;
+}
+.rdp-months {
+  width: 100%;
+  max-width: unset !important;
+}
+.rdp-month_caption {
+  text-align: center;
+  width: 100%;
+  height: 36px !important;
+  display: block !important;
+  font-size: 14px !important;
+}
+.rdp-month_grid {
+  width: 100%;
+}
+.rdp-month {
+  width: 100%;
+}
+.rdp-button_previous {
+  background-color: var(--color-overlay-light) !important;
+  border-radius: 50%;
+}
+.rdp-button_previous:hover {
+  background-color: var(--color-overlay-glass) !important;
+}
+.rdp-button_previous > svg {
+  fill: var(--color-text-100) !important;
+  width: 16px !important;
+  height: 16px !important;
+}
+.rdp-button_next {
+  background-color: var(--color-overlay-light) !important;
+  border-radius: 50%;
+}
+.rdp-button_next:hover {
+  background-color: var(--color-overlay-glass) !important;
+}
+.rdp-button_next > svg {
+  fill: var(--color-text-100) !important;
+  width: 16px !important;
+  height: 16px !important;
+}
+.rdp-weekdays {
+  display: flex;
+  justify-content: space-between;
+}
+.rdp-weekday {
+  padding: 16px 0 !important;
+  font-size: 14px !important;
+  font-weight: var(--font-weight-medium) !important;
+  color: var(--color-text-80) !important;
+}
+.rdp-weeks {
+  display: flex;
+  flex-direction: column;
+  gap: 4px;
+}
+.rdp-week {
+  display: flex;
+  justify-content: space-between;
+}
+.rdp-day {
+  width: 24px !important;
+  height: 24px !important;
+}
+.rdp-day_button {
+  width: 24px !important;
+  height: 24px !important;
+  font-size: var(--text-xs) !important;
+  color: var(--color-text-80) !important;
+}
+.rdp-day_button:disabled {
+  color: var(--color-text-50) !important;
+}
+.rdp-day.rdp-today {
+  outline: 1px solid var(--color-violet-700) !important;
+  border-radius: 50% !important;
+}
+.rdp-day.rdp-selected {
+  background: var(--seq-color-gradient-primary) !important;
+  border-radius: 50% !important;
+}
 @keyframes fadeIn {
   0% {
     opacity: 0;
@@ -11463,21 +12642,27 @@ const ShadowRoot = (props) => {
 //#endregion
 //#region src/react/providers/modal-provider.tsx
 const ModalProvider = observer(({ children }) => {
-	const { shadowDom, experimentalShadowDomCssOverride } = useConfig();
-	return /* @__PURE__ */ jsxs(Fragment, { children: [children, /* @__PURE__ */ jsx(SequenceCheckoutProvider, { children: /* @__PURE__ */ jsxs(ShadowRoot, {
-		enabled: shadowDom ?? true,
-		customCSS: experimentalShadowDomCssOverride,
-		children: [
-			/* @__PURE__ */ jsx(CreateListingModal, {}),
-			/* @__PURE__ */ jsx(MakeOfferModal, {}),
-			/* @__PURE__ */ jsx(TransferModal, {}),
-			/* @__PURE__ */ jsx(SellModal, {}),
-			/* @__PURE__ */ jsx(BuyModal, {}),
-			/* @__PURE__ */ jsx(SuccessfulPurchaseModal_default, {}),
-			/* @__PURE__ */ jsx(switchChainErrorModal_default, {}),
-			/* @__PURE__ */ jsx(transactionStatusModal_default, {})
-		]
-	}) })] });
+	const sdkConfig = useConfig();
+	const { shadowDom, experimentalShadowDomCssOverride } = sdkConfig;
+	const overrides = sdkConfig._internal?.overrides?.api?.marketplace;
+	const marketplaceApiUrl = overrides?.url || marketplaceApiURL(overrides?.env || "production");
+	return /* @__PURE__ */ jsxs(Fragment, { children: [children, /* @__PURE__ */ jsx(SequenceCheckoutProvider, {
+		config: { env: { marketplaceApiUrl } },
+		children: /* @__PURE__ */ jsxs(ShadowRoot, {
+			enabled: shadowDom ?? true,
+			customCSS: experimentalShadowDomCssOverride,
+			children: [
+				/* @__PURE__ */ jsx(CreateListingModal, {}),
+				/* @__PURE__ */ jsx(MakeOfferModal, {}),
+				/* @__PURE__ */ jsx(TransferModal, {}),
+				/* @__PURE__ */ jsx(SellModal, {}),
+				/* @__PURE__ */ jsx(BuyModal, {}),
+				/* @__PURE__ */ jsx(SuccessfulPurchaseModal_default, {}),
+				/* @__PURE__ */ jsx(switchChainErrorModal_default, {}),
+				/* @__PURE__ */ jsx(transactionStatusModal_default, {})
+			]
+		})
+	})] });
 });
 
 //#endregion
@@ -11563,7 +12748,7 @@ function ActionButtonBody({ tokenId, label, onClick, icon, action }) {
 //#endregion
 //#region src/react/ui/components/_internals/action-button/components/NonOwnerActions.tsx
 function NonOwnerActions(props) {
-	const { action, tokenId, collectionAddress, chainId, quantityDecimals, quantityRemaining, unlimitedSupply, cardType } = props;
+	const { action, tokenId, collectionAddress, chainId, quantityDecimals, quantityRemaining, unlimitedSupply, cardType, hideQuantitySelector } = props;
 	const { show: showBuyModal } = useBuyModal();
 	const { show: showMakeOfferModal } = useMakeOfferModal();
 	if (cardType === "shop") {
@@ -11587,7 +12772,8 @@ function NonOwnerActions(props) {
 				},
 				quantityDecimals: quantityDecimals ?? 0,
 				quantityRemaining: quantityRemaining ?? 0,
-				unlimitedSupply
+				unlimitedSupply,
+				hideQuantitySelector
 			}),
 			icon: CartIcon_default
 		});
@@ -11605,7 +12791,8 @@ function NonOwnerActions(props) {
 				collectibleId: tokenId,
 				orderId: lowestListing.orderId,
 				marketplace: lowestListing.marketplace,
-				cardType: "market"
+				cardType: "market",
+				hideQuantitySelector
 			}),
 			icon: CartIcon_default
 		});
@@ -11727,7 +12914,7 @@ const useActionButtonLogic = ({ tokenId, owned, action, onCannotPerformAction })
 
 //#endregion
 //#region src/react/ui/components/_internals/action-button/ActionButton.tsx
-function ActionButton({ collectionAddress, chainId, tokenId, orderbookKind, action, owned, highestOffer, lowestListing, onCannotPerformAction, cardType, salesContractAddress, prioritizeOwnerActions, salePrice, quantityDecimals, quantityRemaining, unlimitedSupply }) {
+function ActionButton({ collectionAddress, chainId, tokenId, orderbookKind, action, owned, highestOffer, lowestListing, onCannotPerformAction, cardType, salesContractAddress, prioritizeOwnerActions, salePrice, quantityDecimals, quantityRemaining, unlimitedSupply, hideQuantitySelector }) {
 	const { shouldShowAction, isOwnerAction } = useActionButtonLogic({
 		tokenId,
 		owned,
@@ -11753,7 +12940,8 @@ function ActionButton({ collectionAddress, chainId, tokenId, orderbookKind, acti
 		chainId,
 		quantityDecimals,
 		quantityRemaining,
-		unlimitedSupply
+		unlimitedSupply,
+		hideQuantitySelector
 	} : {
 		cardType: "market",
 		orderbookKind,
@@ -11763,13 +12951,14 @@ function ActionButton({ collectionAddress, chainId, tokenId, orderbookKind, acti
 		collectionAddress,
 		chainId,
 		quantityDecimals,
-		quantityRemaining
+		quantityRemaining,
+		hideQuantitySelector
 	} });
 }
 
 //#endregion
 //#region src/react/ui/components/marketplace-collectible-card/components/ActionButtonWrapper.tsx
-function ActionButtonWrapper({ show, chainId, collectionAddress, tokenId, orderbookKind, action, highestOffer, lowestListing, owned, onCannotPerformAction, cardType, salesContractAddress, prioritizeOwnerActions, salePrice, quantityDecimals, quantityRemaining, unlimitedSupply }) {
+function ActionButtonWrapper({ show, chainId, collectionAddress, tokenId, orderbookKind, action, highestOffer, lowestListing, owned, onCannotPerformAction, cardType, salesContractAddress, prioritizeOwnerActions, salePrice, quantityDecimals, quantityRemaining, unlimitedSupply, hideQuantitySelector }) {
 	if (!show) return null;
 	return /* @__PURE__ */ jsx("div", {
 		className: "-bottom-16 absolute flex w-full origin-bottom items-center justify-center bg-overlay-light p-2 backdrop-blur transition-transform duration-200 ease-in-out group-hover:translate-y-[-64px]",
@@ -11789,7 +12978,8 @@ function ActionButtonWrapper({ show, chainId, collectionAddress, tokenId, orderb
 			salePrice,
 			quantityDecimals,
 			quantityRemaining,
-			unlimitedSupply
+			unlimitedSupply,
+			hideQuantitySelector
 		})
 	});
 }
@@ -12246,7 +13436,7 @@ const NonTradableInventoryFooter = ({ name, balance, decimals, type }) => {
 
 //#endregion
 //#region src/react/ui/components/marketplace-collectible-card/variants/MarketCard.tsx
-function MarketCard({ collectibleId, chainId, collectionAddress, collectionType, assetSrcPrefixUrl, cardLoading, orderbookKind, collectible, onCollectibleClick, onOfferClick, balance, balanceIsLoading = false, onCannotPerformAction, prioritizeOwnerActions }) {
+function MarketCard({ collectibleId, chainId, collectionAddress, collectionType, assetSrcPrefixUrl, cardLoading, orderbookKind, collectible, onCollectibleClick, onOfferClick, balance, balanceIsLoading = false, onCannotPerformAction, prioritizeOwnerActions, hideQuantitySelector }) {
 	const collectibleMetadata = collectible?.metadata;
 	const highestOffer = collectible?.offer;
 	if (!collectibleMetadata) {
@@ -12274,6 +13464,7 @@ function MarketCard({ collectibleId, chainId, collectionAddress, collectionType,
 		isShop: false,
 		onClick: () => onCollectibleClick?.(collectibleId),
 		onKeyDown: handleKeyDown,
+		hideQuantitySelector,
 		children: [/* @__PURE__ */ jsx(Footer, {
 			chainId,
 			collectionAddress,
@@ -12302,7 +13493,8 @@ function MarketCard({ collectibleId, chainId, collectionAddress, collectionType,
 			owned: !!balance,
 			onCannotPerformAction,
 			cardType: "market",
-			prioritizeOwnerActions
+			prioritizeOwnerActions,
+			hideQuantitySelector
 		})]
 	});
 }
@@ -12334,7 +13526,7 @@ function NonTradableInventoryCard({ collectibleId, chainId, collectionAddress, c
 
 //#endregion
 //#region src/react/ui/components/marketplace-collectible-card/variants/ShopCard.tsx
-function ShopCard({ collectibleId, chainId, collectionAddress, collectionType, assetSrcPrefixUrl, cardLoading, cardType, salesContractAddress, tokenMetadata, salePrice, quantityDecimals, quantityInitial, quantityRemaining, unlimitedSupply }) {
+function ShopCard({ collectibleId, chainId, collectionAddress, collectionType, assetSrcPrefixUrl, cardLoading, cardType, salesContractAddress, tokenMetadata, salePrice, quantityDecimals, quantityInitial, quantityRemaining, unlimitedSupply, hideQuantitySelector }) {
 	const { data: saleCurrency, isLoading: saleCurrencyLoading } = useCurrency({
 		chainId,
 		currencyAddress: salePrice?.currencyAddress,
@@ -12365,6 +13557,7 @@ function ShopCard({ collectibleId, chainId, collectionAddress, collectionType, a
 		mediaClassName,
 		contractType: collectionType,
 		isShop: true,
+		hideQuantitySelector,
 		children: [/* @__PURE__ */ jsx(Footer, {
 			chainId,
 			collectionAddress,
@@ -12406,5 +13599,5 @@ function CollectibleCard(props) {
 }
 
 //#endregion
-export { ActionModal, CollectibleCard, DatabeatAnalytics, Footer, MarketplaceProvider, MarketplaceQueryClientProvider, MarketplaceSdkContext, Media, ModalProvider, NonTradableInventoryFooter, collectionDetailsPollingOptions, generateCancelTransaction, generateListingTransaction, generateOfferTransaction, generateSellTransaction, useAnalytics, useAutoSelectFeeOption, useBalanceOfCollectible, useBuyModal, useCancelOrder, useCancelTransactionSteps, useCheckoutOptions$1 as useCheckoutOptions, useCheckoutOptionsSalesContract, useCollectible, useCollection, useCollectionBalanceDetails, useCollectionDetails, useCollectionDetailsPolling, useComparePrices, useConfig, useConnectorMetadata, useConvertPriceToUSD, useCountListingsForCollectible, useCountOfCollectables, useCountOfPrimarySaleItems, useCountOffersForCollectible, useCreateListingModal, useCurrency, useEnsureCorrectChain, useErc721SaleDetails, useFilterState, useFilters, useFiltersProgressive, useFloorOrder, useGenerateCancelTransaction, useGenerateListingTransaction, useGenerateOfferTransaction, useGenerateSellTransaction, useGetCountOfPrimarySaleItems, useGetReceiptFromHash, useGetTokenRanges, useHighestOffer, useInventory, useList1155ShopCardData, useList721ShopCardData, useListBalances, useListCollectibleActivities, useListCollectibles, useListCollectiblesPaginated, useListCollectionActivities, useListCollections, useListListingsForCollectible, useListMarketCardData, useListOffersForCollectible, useListPrimarySaleItems, useListTokenMetadata, useLowestListing, useMakeOfferModal, useMarketCurrencies, useMarketplaceConfig, useOpenConnectModal$1 as useOpenConnectModal, useOrderSteps, useProcessStep, useRoyalty, useSearchTokenMetadata, useSellModal, useSuccessfulPurchaseModal, useTokenSupplies, useTransferModal, useTransferTokens };
-//# sourceMappingURL=react-BLJ4DkPx.js.map
+export { ActionModal, CollectibleCard, DatabeatAnalytics, Footer, MarketplaceProvider, MarketplaceQueryClientProvider, MarketplaceSdkContext, Media, ModalProvider, NonTradableInventoryFooter, collectionDetailsPollingOptions, generateCancelTransaction, generateListingTransaction, generateOfferTransaction, generateSellTransaction, useAnalytics, useAutoSelectFeeOption, useBalanceOfCollectible, useBuyModal, useCancelOrder, useCancelTransactionSteps, useCheckoutOptions$1 as useCheckoutOptions, useCheckoutOptionsSalesContract, useCollectible, useCollection, useCollectionBalanceDetails, useCollectionDetails, useCollectionDetailsPolling, useComparePrices, useConfig, useConnectorMetadata, useConvertPriceToUSD, useCountItemsOrdersForCollection, useCountListingsForCollectible, useCountOfCollectables, useCountOfPrimarySaleItems, useCountOffersForCollectible, useCreateListingModal, useCurrency, useEnsureCorrectChain, useErc721SaleDetails, useFilterState, useFilters, useFiltersProgressive, useFloorOrder, useGenerateCancelTransaction, useGenerateListingTransaction, useGenerateOfferTransaction, useGenerateSellTransaction, useGetCountOfFilteredOrders, useGetCountOfPrimarySaleItems, useGetReceiptFromHash, useGetTokenRanges, useHighestOffer, useInventory, useList1155ShopCardData, useList721ShopCardData, useListBalances, useListCollectibleActivities, useListCollectibles, useListCollectiblesPaginated, useListCollectionActivities, useListCollections, useListItemsOrdersForCollection, useListItemsOrdersForCollectionPaginated, useListListingsForCollectible, useListMarketCardData, useListOffersForCollectible, useListPrimarySaleItems, useListTokenMetadata, useLowestListing, useMakeOfferModal, useMarketCurrencies, useMarketplaceConfig, useOpenConnectModal$1 as useOpenConnectModal, useOrderSteps, useProcessStep, useRoyalty, useSearchTokenMetadata, useSellModal, useSuccessfulPurchaseModal, useTokenSupplies, useTransferModal, useTransferTokens };
+//# sourceMappingURL=react-DE852KeT.js.map