@0xsequence/marketplace-sdk 0.0.1 → 0.1.0

package/dist/chunk-ITJEOCDV.js

@@ -0,0 +1,1006 @@
+"use client"
+import {
+  getPublicRpcClient
+} from "./chunk-RNUHUVLC.js";
+import {
+  EIP2981_ABI
+} from "./chunk-DBFOPEV6.js";
+import {
+  ERC1155_ABI
+} from "./chunk-O5JXKTWP.js";
+import {
+  AddressSchema,
+  ChainIdSchema,
+  PROVIDER_ID,
+  QueryArgSchema
+} from "./chunk-7CL54NCX.js";
+import {
+  CollectibleStatus,
+  CollectionStatus,
+  ContractType,
+  ExecuteType,
+  MarketplaceKind,
+  OrderSide,
+  OrderStatus,
+  OrderbookKind,
+  ProjectStatus,
+  PropertyType,
+  SortOrder,
+  SourceKind,
+  StepType,
+  TransactionCrypto,
+  TransactionNFTCheckoutProvider,
+  TransactionOnRampProvider,
+  TransactionSwapProvider,
+  WalletKind,
+  balanceQueries,
+  builderMarketplaceApi,
+  collectableKeys,
+  collectionKeys,
+  configKeys,
+  currencyKeys,
+  getIndexerClient,
+  getMarketplaceClient,
+  getMetadataClient,
+  getQueryClient
+} from "./chunk-HGBEC3WX.js";
+
+// src/react/provider.tsx
+import { createContext } from "react";
+import "@0xsequence/design-system/styles.css";
+import { jsx } from "react/jsx-runtime";
+var MarketplaceSdkContext = createContext({});
+function MarketplaceProvider({
+  config,
+  children
+}) {
+  return /* @__PURE__ */ jsx(MarketplaceSdkContext.Provider, { value: config, children: /* @__PURE__ */ jsx("div", { id: PROVIDER_ID, children }) });
+}
+
+// src/react/hooks/useConfig.tsx
+import { useContext } from "react";
+function useConfig() {
+  const context = useContext(MarketplaceSdkContext);
+  if (!context) {
+    throw new Error(
+      "Marketplace SDK must be used within a MarketplaceSdkProvider"
+    );
+  }
+  return context;
+}
+
+// src/react/hooks/useCollectible.tsx
+import { queryOptions, useQuery } from "@tanstack/react-query";
+import { z } from "zod";
+var UseCollectibleSchema = z.object({
+  chainId: ChainIdSchema.pipe(z.coerce.string()),
+  collectionAddress: AddressSchema,
+  collectibleId: z.string(),
+  query: QueryArgSchema
+});
+var fetchCollectible = async (args, config) => {
+  const parsedArgs = UseCollectibleSchema.parse(args);
+  const metadataClient = getMetadataClient(config);
+  return metadataClient.getTokenMetadata({
+    chainID: parsedArgs.chainId,
+    contractAddress: parsedArgs.collectionAddress,
+    tokenIDs: [parsedArgs.collectibleId]
+  }).then((resp) => resp.tokenMetadata[0]);
+};
+var collectibleOptions = (args, config) => {
+  return queryOptions({
+    ...args.query,
+    queryKey: [...collectableKeys.details, args, config],
+    queryFn: () => fetchCollectible(args, config)
+  });
+};
+var useCollectible = (args) => {
+  const config = useConfig();
+  return useQuery(collectibleOptions(args, config));
+};
+
+// src/react/hooks/useCollection.tsx
+import { queryOptions as queryOptions2, useQuery as useQuery2 } from "@tanstack/react-query";
+import { z as z2 } from "zod";
+var UseCollectionSchema = z2.object({
+  chainId: ChainIdSchema.pipe(z2.coerce.string()),
+  collectionAddress: AddressSchema,
+  query: QueryArgSchema
+});
+var fetchCollection = async (args, config) => {
+  const parsedArgs = UseCollectionSchema.parse(args);
+  const metadataClient = getMetadataClient(config);
+  return metadataClient.getContractInfo({
+    chainID: parsedArgs.chainId,
+    contractAddress: parsedArgs.collectionAddress
+  }).then((resp) => resp.contractInfo);
+};
+var collectionOptions = (args, config) => {
+  return queryOptions2({
+    ...args.query,
+    queryKey: [...collectionKeys.detail, args, config],
+    queryFn: () => fetchCollection(args, config)
+  });
+};
+var useCollection = (args) => {
+  const config = useConfig();
+  return useQuery2(collectionOptions(args, config));
+};
+
+// src/react/hooks/useCurrencies.tsx
+import { queryOptions as queryOptions3, useQuery as useQuery3 } from "@tanstack/react-query";
+import { z as z3 } from "zod";
+var ChainIdCoerce = ChainIdSchema.transform((val) => val.toString());
+var UseCurrenciesArgsSchema = z3.object({
+  chainId: ChainIdCoerce,
+  collectionAddress: AddressSchema.optional(),
+  includeNativeCurrency: z3.boolean().optional(),
+  query: QueryArgSchema
+});
+var fetchCurrencies = async (chainId, config) => {
+  const parsedChainId = ChainIdCoerce.parse(chainId);
+  const marketplaceClient = getMarketplaceClient(parsedChainId, config);
+  return marketplaceClient.listCurrencies().then((resp) => resp.currencies);
+};
+var selectCurrencies = (data, args) => {
+  const argsParsed = UseCurrenciesArgsSchema.parse(args);
+  if (argsParsed.collectionAddress) {
+    const queryClient = getQueryClient();
+    const marketplaceConfigCache = queryClient.getQueriesData({
+      queryKey: configKeys.marketplace
+    })[0][1];
+    const collection = marketplaceConfigCache?.collections.find(
+      (collection2) => collection2.collectionAddress === argsParsed.collectionAddress
+    );
+    if (!collection) {
+      throw new Error("Collection doesn't exist");
+    }
+    return data.filter(
+      (currency) => collection.currencyOptions?.includes(currency.contractAddress) || // biome-ignore lint/suspicious/noDoubleEquals: <explanation>
+      currency.nativeCurrency == argsParsed.includeNativeCurrency || currency.defaultChainCurrency
+    );
+  }
+  if (argsParsed.includeNativeCurrency) {
+    return data;
+  }
+  return data.filter((currency) => !currency.nativeCurrency);
+};
+var currenciesOptions = (args, config) => {
+  return queryOptions3({
+    ...args.query,
+    queryKey: [...currencyKeys.lists, args.chainId],
+    queryFn: () => fetchCurrencies(args.chainId, config),
+    select: (data) => selectCurrencies(data, args),
+    enabled: args.query?.enabled
+  });
+};
+var useCurrencies = (args) => {
+  const config = useConfig();
+  return useQuery3(currenciesOptions(args, config));
+};
+
+// src/react/hooks/useListBalances.tsx
+import { SortOrder as SortOrder2 } from "@0xsequence/indexer";
+import { infiniteQueryOptions, useInfiniteQuery } from "@tanstack/react-query";
+import { z as z4 } from "zod";
+var metadataOptionsSchema = z4.object({
+  verifiedOnly: z4.boolean().optional(),
+  unverifiedOnly: z4.boolean().optional(),
+  includeContracts: z4.array(z4.string()).optional()
+});
+var sortOrderSchema = z4.nativeEnum(SortOrder2);
+var sortBySchema = z4.object({
+  column: z4.string(),
+  order: sortOrderSchema
+});
+var pageSchema = z4.object({
+  page: z4.number().optional(),
+  column: z4.string().optional(),
+  before: z4.any().optional(),
+  after: z4.any().optional(),
+  sort: z4.array(sortBySchema).optional(),
+  pageSize: z4.number().optional(),
+  more: z4.boolean().optional()
+});
+var useListBalancesArgsSchema = z4.object({
+  chainId: ChainIdSchema.pipe(z4.coerce.number()),
+  accountAddress: AddressSchema.optional(),
+  contractAddress: AddressSchema.optional(),
+  tokenId: z4.string().optional(),
+  includeMetadata: z4.boolean().optional(),
+  metadataOptions: metadataOptionsSchema.optional(),
+  includeCollectionTokens: z4.boolean().optional(),
+  page: pageSchema.optional(),
+  query: QueryArgSchema
+});
+var fetchBalances = async (args, page, config) => {
+  const parsedArgs = useListBalancesArgsSchema.parse(args);
+  const indexerClient = getIndexerClient(parsedArgs.chainId, config);
+  return indexerClient.getTokenBalances({
+    ...parsedArgs,
+    tokenID: parsedArgs.tokenId,
+    page
+  });
+};
+var listBalancesOptions = (args, config) => {
+  return infiniteQueryOptions({
+    ...args.query,
+    queryKey: [...balanceQueries.lists, args, config],
+    queryFn: ({ pageParam }) => fetchBalances(args, pageParam, config),
+    initialPageParam: { page: 1, pageSize: 30 },
+    getNextPageParam: (lastPage) => lastPage.page.after
+  });
+};
+var useListBalances = (args) => {
+  const config = useConfig();
+  return useInfiniteQuery(listBalancesOptions(args, config));
+};
+
+// src/react/hooks/useLowestListing.tsx
+import { queryOptions as queryOptions4, useQuery as useQuery4 } from "@tanstack/react-query";
+import { z as z6 } from "zod";
+
+// src/react/_internal/api/zod-schema.ts
+import { z as z5 } from "zod";
+var assetSchema = z5.object({
+  id: z5.number(),
+  collectionId: z5.number(),
+  tokenId: z5.string(),
+  url: z5.string().optional(),
+  metadataField: z5.string(),
+  name: z5.string().optional(),
+  filesize: z5.number().optional(),
+  mimeType: z5.string().optional(),
+  width: z5.number().optional(),
+  height: z5.number().optional(),
+  updatedAt: z5.string().optional()
+});
+var sortOrderSchema2 = z5.nativeEnum(SortOrder);
+var propertyTypeSchema = z5.nativeEnum(PropertyType);
+var marketplaceKindSchema = z5.nativeEnum(MarketplaceKind);
+var orderbookKindSchema = z5.nativeEnum(OrderbookKind);
+var sourceKindSchema = z5.nativeEnum(SourceKind);
+var orderSideSchema = z5.nativeEnum(OrderSide);
+var orderStatusSchema = z5.nativeEnum(OrderStatus);
+var contractTypeSchema = z5.nativeEnum(ContractType);
+var collectionStatusSchema = z5.nativeEnum(CollectionStatus);
+var projectStatusSchema = z5.nativeEnum(ProjectStatus);
+var collectibleStatusSchema = z5.nativeEnum(CollectibleStatus);
+var walletKindSchema = z5.nativeEnum(WalletKind);
+var stepTypeSchema = z5.nativeEnum(StepType);
+var transactionCryptoSchema = z5.nativeEnum(TransactionCrypto);
+var transactionNFTCheckoutProviderSchema = z5.nativeEnum(
+  TransactionNFTCheckoutProvider
+);
+var transactionOnRampProviderSchema = z5.nativeEnum(
+  TransactionOnRampProvider
+);
+var transactionSwapProviderSchema = z5.nativeEnum(
+  TransactionSwapProvider
+);
+var executeTypeSchema = z5.nativeEnum(ExecuteType);
+var sortBySchema2 = z5.object({
+  column: z5.string(),
+  order: sortOrderSchema2
+});
+var propertyFilterSchema = z5.object({
+  name: z5.string(),
+  type: propertyTypeSchema,
+  min: z5.number().optional(),
+  max: z5.number().optional(),
+  values: z5.array(z5.any()).optional()
+});
+var collectiblesFilterSchema = z5.object({
+  includeEmpty: z5.boolean(),
+  searchText: z5.string().optional(),
+  properties: z5.array(propertyFilterSchema).optional(),
+  marketplaces: z5.array(marketplaceKindSchema).optional(),
+  inAccounts: z5.array(z5.string()).optional(),
+  notInAccounts: z5.array(z5.string()).optional(),
+  ordersCreatedBy: z5.array(z5.string()).optional(),
+  ordersNotCreatedBy: z5.array(z5.string()).optional()
+});
+var feeBreakdownSchema = z5.object({
+  kind: z5.string(),
+  recipientAddress: z5.string(),
+  bps: z5.number()
+});
+var orderFilterSchema = z5.object({
+  createdBy: z5.array(z5.string()).optional(),
+  marketplace: z5.array(marketplaceKindSchema).optional(),
+  currencies: z5.array(z5.string()).optional()
+});
+var collectionLastSyncedSchema = z5.object({
+  allOrders: z5.string(),
+  newOrders: z5.string()
+});
+var projectSchema = z5.object({
+  projectId: z5.number(),
+  chainId: z5.number(),
+  contractAddress: z5.string(),
+  status: projectStatusSchema,
+  createdAt: z5.string(),
+  updatedAt: z5.string(),
+  deletedAt: z5.string().optional()
+});
+var collectibleSchema = z5.object({
+  chainId: z5.number(),
+  contractAddress: z5.string(),
+  status: collectibleStatusSchema,
+  tokenId: z5.string(),
+  createdAt: z5.string(),
+  updatedAt: z5.string(),
+  deletedAt: z5.string().optional()
+});
+var currencySchema = z5.object({
+  chainId: z5.number(),
+  contractAddress: z5.string(),
+  name: z5.string(),
+  symbol: z5.string(),
+  decimals: z5.number(),
+  imageUrl: z5.string(),
+  exchangeRate: z5.number(),
+  defaultChainCurrency: z5.boolean(),
+  nativeCurrency: z5.boolean(),
+  createdAt: z5.string(),
+  updatedAt: z5.string(),
+  deletedAt: z5.string().optional()
+});
+var orderDataSchema = z5.object({
+  orderId: z5.string(),
+  quantity: z5.string()
+});
+var additionalFeeSchema = z5.object({
+  amount: z5.string(),
+  receiver: z5.string()
+});
+var postRequestSchema = z5.object({
+  endpoint: z5.string(),
+  method: z5.string(),
+  body: z5.any()
+});
+var createReqSchema = z5.object({
+  tokenId: z5.string(),
+  quantity: z5.string(),
+  expiry: z5.string(),
+  currencyAddress: z5.string(),
+  pricePerToken: z5.string()
+});
+var getOrdersInputSchema = z5.object({
+  contractAddress: z5.string(),
+  orderId: z5.string(),
+  marketplace: marketplaceKindSchema
+});
+var domainSchema = z5.object({
+  name: z5.string(),
+  version: z5.string(),
+  chainId: z5.number(),
+  verifyingContract: z5.string()
+});
+var checkoutOptionsMarketplaceOrderSchema = z5.object({
+  contractAddress: z5.string(),
+  orderId: z5.string(),
+  marketplace: marketplaceKindSchema
+});
+var checkoutOptionsItemSchema = z5.object({
+  tokenId: z5.string(),
+  quantity: z5.string()
+});
+var checkoutOptionsSchema = z5.object({
+  crypto: transactionCryptoSchema,
+  swap: z5.array(transactionSwapProviderSchema),
+  nftCheckout: z5.array(transactionNFTCheckoutProviderSchema),
+  onRamp: z5.array(transactionOnRampProviderSchema)
+});
+var listCurrenciesArgsSchema = z5.object({});
+var listCurrenciesReturnSchema = z5.object({
+  currencies: z5.array(currencySchema)
+});
+var getCollectibleArgsSchema = z5.object({
+  contractAddress: z5.string(),
+  tokenId: z5.string()
+});
+var getLowestPriceOfferForCollectibleArgsSchema = z5.object({
+  contractAddress: z5.string(),
+  tokenId: z5.string(),
+  filter: orderFilterSchema.optional()
+});
+var getHighestPriceOfferForCollectibleArgsSchema = z5.object({
+  contractAddress: z5.string(),
+  tokenId: z5.string(),
+  filter: orderFilterSchema.optional()
+});
+var getLowestPriceListingForCollectibleArgsSchema = z5.object({
+  contractAddress: z5.string(),
+  tokenId: z5.string(),
+  filter: orderFilterSchema.optional()
+});
+var getHighestPriceListingForCollectibleArgsSchema = z5.object({
+  contractAddress: z5.string(),
+  tokenId: z5.string(),
+  filter: orderFilterSchema.optional()
+});
+var getCollectibleLowestOfferArgsSchema = z5.object({
+  contractAddress: z5.string(),
+  tokenId: z5.string(),
+  filter: orderFilterSchema.optional()
+});
+var getCollectibleHighestOfferArgsSchema = z5.object({
+  contractAddress: z5.string(),
+  tokenId: z5.string(),
+  filter: orderFilterSchema.optional()
+});
+var getCollectibleLowestListingArgsSchema = z5.object({
+  contractAddress: z5.string(),
+  tokenId: z5.string(),
+  filters: orderFilterSchema.optional()
+});
+var getCollectibleHighestListingArgsSchema = z5.object({
+  contractAddress: z5.string(),
+  tokenId: z5.string(),
+  filter: orderFilterSchema.optional()
+});
+var generateBuyTransactionArgsSchema = z5.object({
+  collectionAddress: z5.string(),
+  buyer: z5.string(),
+  marketplace: marketplaceKindSchema,
+  ordersData: z5.array(orderDataSchema),
+  additionalFees: z5.array(additionalFeeSchema),
+  walletType: walletKindSchema.optional()
+});
+var generateSellTransactionArgsSchema = z5.object({
+  collectionAddress: z5.string(),
+  seller: z5.string(),
+  marketplace: marketplaceKindSchema,
+  ordersData: z5.array(orderDataSchema),
+  additionalFees: z5.array(additionalFeeSchema),
+  walletType: walletKindSchema.optional()
+});
+var generateListingTransactionArgsSchema = z5.object({
+  collectionAddress: z5.string(),
+  owner: z5.string(),
+  contractType: contractTypeSchema,
+  orderbook: orderbookKindSchema,
+  listing: createReqSchema,
+  walletType: walletKindSchema.optional()
+});
+var generateOfferTransactionArgsSchema = z5.object({
+  collectionAddress: z5.string(),
+  maker: z5.string(),
+  contractType: contractTypeSchema,
+  orderbook: orderbookKindSchema,
+  offer: createReqSchema,
+  walletType: walletKindSchema.optional()
+});
+var executeArgsSchema = z5.object({
+  signature: z5.string(),
+  executeType: executeTypeSchema,
+  body: z5.any()
+});
+var executeReturnSchema = z5.object({
+  orderId: z5.string()
+});
+var getCountOfAllCollectiblesArgsSchema = z5.object({
+  contractAddress: z5.string()
+});
+var getCountOfAllCollectiblesReturnSchema = z5.object({
+  count: z5.number()
+});
+var getCountOfFilteredCollectiblesArgsSchema = z5.object({
+  side: orderSideSchema,
+  contractAddress: z5.string(),
+  filter: collectiblesFilterSchema.optional()
+});
+var getCountOfFilteredCollectiblesReturnSchema = z5.object({
+  count: z5.number()
+});
+var getFloorOrderArgsSchema = z5.object({
+  contractAddress: z5.string(),
+  filter: collectiblesFilterSchema.optional()
+});
+var syncOrderReturnSchema = z5.object({});
+var syncOrdersReturnSchema = z5.object({});
+var checkoutOptionsMarketplaceArgsSchema = z5.object({
+  wallet: z5.string(),
+  orders: z5.array(checkoutOptionsMarketplaceOrderSchema),
+  additionalFee: z5.number()
+});
+var checkoutOptionsMarketplaceReturnSchema = z5.object({
+  options: checkoutOptionsSchema
+});
+var checkoutOptionsSalesContractArgsSchema = z5.object({
+  wallet: z5.string(),
+  contractAddress: z5.string(),
+  collectionAddress: z5.string(),
+  items: z5.array(checkoutOptionsItemSchema)
+});
+var checkoutOptionsSalesContractReturnSchema = z5.object({
+  options: checkoutOptionsSchema
+});
+var tokenMetadataSchema = z5.object({
+  tokenId: z5.string(),
+  name: z5.string(),
+  description: z5.string().optional(),
+  image: z5.string().optional(),
+  video: z5.string().optional(),
+  audio: z5.string().optional(),
+  properties: z5.record(z5.any()).optional(),
+  attributes: z5.array(z5.record(z5.any())),
+  image_data: z5.string().optional(),
+  external_url: z5.string().optional(),
+  background_color: z5.string().optional(),
+  animation_url: z5.string().optional(),
+  decimals: z5.number().optional(),
+  updatedAt: z5.string().optional(),
+  assets: z5.array(assetSchema).optional()
+});
+var pageSchema2 = z5.object({
+  page: z5.number(),
+  pageSize: z5.number(),
+  more: z5.boolean().optional(),
+  sort: z5.array(sortBySchema2).optional()
+});
+var filterSchema = z5.object({
+  text: z5.string().optional(),
+  properties: z5.array(propertyFilterSchema).optional()
+});
+var orderSchema = z5.object({
+  orderId: z5.string(),
+  marketplace: marketplaceKindSchema,
+  side: orderSideSchema,
+  status: orderStatusSchema,
+  chainId: z5.number(),
+  collectionContractAddress: z5.string(),
+  tokenId: z5.string(),
+  createdBy: z5.string(),
+  priceAmount: z5.string(),
+  priceAmountFormatted: z5.string(),
+  priceAmountNet: z5.string(),
+  priceAmountNetFormatted: z5.string(),
+  priceCurrencyAddress: z5.string(),
+  priceDecimals: z5.number(),
+  priceUSD: z5.number(),
+  quantityInitial: z5.string(),
+  quantityInitialFormatted: z5.string(),
+  quantityRemaining: z5.string(),
+  quantityRemainingFormatted: z5.string(),
+  quantityAvailable: z5.string(),
+  quantityAvailableFormatted: z5.string(),
+  quantityDecimals: z5.number(),
+  feeBps: z5.number(),
+  feeBreakdown: z5.array(feeBreakdownSchema),
+  validFrom: z5.string(),
+  validUntil: z5.string(),
+  blockNumber: z5.number(),
+  orderCreatedAt: z5.string().optional(),
+  orderUpdatedAt: z5.string().optional(),
+  createdAt: z5.string(),
+  updatedAt: z5.string(),
+  deletedAt: z5.string().optional()
+});
+var collectibleOrderSchema = z5.object({
+  metadata: tokenMetadataSchema,
+  order: orderSchema.optional()
+});
+var activitySchema = z5.object({
+  type: z5.string(),
+  fromAddress: z5.string(),
+  toAddress: z5.string(),
+  txHash: z5.string(),
+  timestamp: z5.number(),
+  tokenId: z5.string(),
+  tokenImage: z5.string(),
+  tokenName: z5.string(),
+  currency: currencySchema.optional()
+});
+var collectionConfigSchema = z5.object({
+  lastSynced: z5.record(collectionLastSyncedSchema),
+  collectiblesSynced: z5.string()
+});
+var signatureSchema = z5.object({
+  domain: domainSchema,
+  types: z5.any(),
+  primaryType: z5.string(),
+  value: z5.any()
+});
+var getCollectibleReturnSchema = z5.object({
+  metadata: tokenMetadataSchema
+});
+var getLowestPriceOfferForCollectibleReturnSchema = z5.object({
+  order: orderSchema
+});
+var getHighestPriceOfferForCollectibleReturnSchema = z5.object({
+  order: orderSchema
+});
+var getLowestPriceListingForCollectibleReturnSchema = z5.object({
+  order: orderSchema
+});
+var getHighestPriceListingForCollectibleReturnSchema = z5.object({
+  order: orderSchema
+});
+var listListingsForCollectibleArgsSchema = z5.object({
+  contractAddress: z5.string(),
+  tokenId: z5.string(),
+  filter: orderFilterSchema.optional(),
+  page: pageSchema2.optional()
+});
+var listListingsForCollectibleReturnSchema = z5.object({
+  listings: z5.array(orderSchema),
+  page: pageSchema2.optional()
+});
+var listOffersForCollectibleArgsSchema = z5.object({
+  contractAddress: z5.string(),
+  tokenId: z5.string(),
+  filter: orderFilterSchema.optional(),
+  page: pageSchema2.optional()
+});
+var listOffersForCollectibleReturnSchema = z5.object({
+  offers: z5.array(orderSchema),
+  page: pageSchema2.optional()
+});
+var getCollectibleLowestOfferReturnSchema = z5.object({
+  order: orderSchema.optional()
+});
+var getCollectibleHighestOfferReturnSchema = z5.object({
+  order: orderSchema.optional()
+});
+var getCollectibleLowestListingReturnSchema = z5.object({
+  order: orderSchema.optional()
+});
+var getCollectibleHighestListingReturnSchema = z5.object({
+  order: orderSchema.optional()
+});
+var listCollectibleListingsArgsSchema = z5.object({
+  contractAddress: z5.string(),
+  tokenId: z5.string(),
+  filter: orderFilterSchema.optional(),
+  page: pageSchema2.optional()
+});
+var listCollectibleListingsReturnSchema = z5.object({
+  listings: z5.array(orderSchema),
+  page: pageSchema2.optional()
+});
+var listCollectibleOffersArgsSchema = z5.object({
+  contractAddress: z5.string(),
+  tokenId: z5.string(),
+  filter: orderFilterSchema.optional(),
+  page: pageSchema2.optional()
+});
+var listCollectibleOffersReturnSchema = z5.object({
+  offers: z5.array(orderSchema),
+  page: pageSchema2.optional()
+});
+var listCollectiblesArgsSchema = z5.object({
+  side: orderSideSchema,
+  contractAddress: z5.string(),
+  filter: collectiblesFilterSchema.optional(),
+  page: pageSchema2.optional()
+});
+var listCollectiblesReturnSchema = z5.object({
+  collectibles: z5.array(collectibleOrderSchema),
+  page: pageSchema2.optional()
+});
+var getFloorOrderReturnSchema = z5.object({
+  collectible: collectibleOrderSchema
+});
+var listCollectiblesWithLowestListingArgsSchema = z5.object({
+  contractAddress: z5.string(),
+  filter: collectiblesFilterSchema.optional(),
+  page: pageSchema2.optional()
+});
+var listCollectiblesWithLowestListingReturnSchema = z5.object({
+  collectibles: z5.array(collectibleOrderSchema),
+  page: pageSchema2.optional()
+});
+var listCollectiblesWithHighestOfferArgsSchema = z5.object({
+  contractAddress: z5.string(),
+  filter: collectiblesFilterSchema.optional(),
+  page: pageSchema2.optional()
+});
+var listCollectiblesWithHighestOfferReturnSchema = z5.object({
+  collectibles: z5.array(collectibleOrderSchema),
+  page: pageSchema2.optional()
+});
+var syncOrderArgsSchema = z5.object({
+  order: orderSchema
+});
+var syncOrdersArgsSchema = z5.object({
+  orders: z5.array(orderSchema)
+});
+var getOrdersArgsSchema = z5.object({
+  input: z5.array(getOrdersInputSchema),
+  page: pageSchema2.optional()
+});
+var getOrdersReturnSchema = z5.object({
+  orders: z5.array(orderSchema),
+  page: pageSchema2.optional()
+});
+var collectionSchema = z5.object({
+  status: collectionStatusSchema,
+  chainId: z5.number(),
+  contractAddress: z5.string(),
+  contractType: contractTypeSchema,
+  tokenQuantityDecimals: z5.number(),
+  config: collectionConfigSchema,
+  createdAt: z5.string(),
+  updatedAt: z5.string(),
+  deletedAt: z5.string().optional()
+});
+var stepSchema = z5.object({
+  id: stepTypeSchema,
+  data: z5.string(),
+  to: z5.string(),
+  value: z5.string(),
+  signature: signatureSchema.optional(),
+  post: postRequestSchema.optional(),
+  executeType: executeTypeSchema.optional()
+});
+var generateBuyTransactionReturnSchema = z5.object({
+  steps: z5.array(stepSchema)
+});
+var generateSellTransactionReturnSchema = z5.object({
+  steps: z5.array(stepSchema)
+});
+var generateListingTransactionReturnSchema = z5.object({
+  steps: z5.array(stepSchema)
+});
+var generateOfferTransactionReturnSchema = z5.object({
+  steps: z5.array(stepSchema)
+});
+
+// src/react/hooks/useLowestListing.tsx
+var UseLowestListingSchema = getCollectibleLowestListingArgsSchema.omit({
+  contractAddress: true
+}).extend({
+  collectionAddress: AddressSchema,
+  chainId: ChainIdSchema.pipe(z6.coerce.string()),
+  query: QueryArgSchema
+});
+var fetchLowestListing = async (args, config) => {
+  const parsedArgs = UseLowestListingSchema.parse(args);
+  const marketplaceClient = getMarketplaceClient(parsedArgs.chainId, config);
+  return marketplaceClient.getCollectibleLowestListing({
+    ...parsedArgs,
+    contractAddress: parsedArgs.collectionAddress
+  });
+};
+var lowestListingOptions = (args, config) => {
+  return queryOptions4({
+    ...args.query,
+    queryKey: [...collectableKeys.lowestListings, args, config],
+    queryFn: () => fetchLowestListing(args, config)
+  });
+};
+var useLowestListing = (args) => {
+  const config = useConfig();
+  return useQuery4(lowestListingOptions(args, config));
+};
+
+// src/react/hooks/options/marketplaceConfigOptions.ts
+import { queryOptions as queryOptions5 } from "@tanstack/react-query";
+var fetchBuilderConfig = async (projectId, env) => {
+  const url = `${builderMarketplaceApi(projectId, env)}`;
+  const response = await fetch(`${url}/config.json`);
+  const json = await response.json();
+  if (!response.ok) {
+    console.error("Failed to fetch marketplace config:", response.status, json);
+    switch (json.code) {
+      case 3e3:
+        throw new Error(`Project id: ${projectId} not found, ${url}`);
+      default:
+        throw new Error(`Failed to fetch marketplace config: ${json.msg}`);
+    }
+  }
+  return json;
+};
+var fetchStyles = async (projectId, env) => {
+  const response = await fetch(
+    `${builderMarketplaceApi(projectId, env)}/styles.css`
+  );
+  const styles = await response.text();
+  return styles.replaceAll(/['"]/g, "");
+};
+var fetchMarketplaceConfig = async (env, projectId) => {
+  const [marketplaceConfig, cssString] = await Promise.all([
+    fetchBuilderConfig(projectId, env),
+    fetchStyles(projectId, env)
+  ]);
+  return {
+    ...marketplaceConfig,
+    cssString,
+    manifestUrl: `${builderMarketplaceApi(projectId, env)}/manifest.json`
+  };
+};
+var marketplaceConfigOptions = (config) => {
+  let env = "production";
+  if ("_internal" in config && config._internal !== void 0) {
+    env = config._internal.builderEnv ?? env;
+  }
+  const projectId = config.projectId;
+  return queryOptions5({
+    queryKey: [...configKeys.marketplace, env, projectId],
+    queryFn: () => fetchMarketplaceConfig(env, projectId)
+  });
+};
+
+// src/react/hooks/useMarketplaceConfig.tsx
+import { useQuery as useQuery5 } from "@tanstack/react-query";
+var useMarketplaceConfig = () => {
+  const config = useConfig();
+  return useQuery5(marketplaceConfigOptions(config));
+};
+
+// src/react/hooks/useRoyaltyPercentage.tsx
+import { queryOptions as queryOptions6, useQuery as useQuery6 } from "@tanstack/react-query";
+import { getContract } from "viem";
+import { z as z7 } from "zod";
+var UseRoyaletyPercentageSchema = z7.object({
+  chainId: ChainIdSchema.pipe(z7.coerce.string()),
+  collectionAddress: AddressSchema,
+  collectibleId: z7.string(),
+  query: QueryArgSchema
+});
+var fetchRoyaletyPercentage = async (args) => {
+  const parsedArgs = UseRoyaletyPercentageSchema.parse(args);
+  const publicClient = getPublicRpcClient(parsedArgs.chainId);
+  const contract = getContract({
+    address: parsedArgs.collectionAddress,
+    abi: EIP2981_ABI,
+    client: publicClient
+  });
+  try {
+    const [_, royaltyPercentage] = await contract.read.royaltyInfo([
+      BigInt(args.collectibleId),
+      100n
+    ]);
+    return royaltyPercentage;
+  } catch {
+    return 0n;
+  }
+};
+var royaletyPercentageOptions = (args) => queryOptions6({
+  ...args.query,
+  queryKey: [...collectableKeys.royaltyPercentage, args],
+  queryFn: () => fetchRoyaletyPercentage(args)
+});
+var useRoyaltyPercentage = (args) => {
+  return useQuery6(royaletyPercentageOptions(args));
+};
+
+// src/react/hooks/useGenerateListingTransaction.tsx
+import { useMutation } from "@tanstack/react-query";
+var dateToUnixTime = (date) => Math.floor(date.getTime() / 1e3).toString();
+var generateListingTransaction = async (params, config, chainId) => {
+  const args = {
+    ...params,
+    listing: {
+      ...params.listing,
+      expiry: dateToUnixTime(params.listing.expiry)
+    }
+  };
+  const marketplaceClient = getMarketplaceClient(chainId, config);
+  return (await marketplaceClient.generateListingTransaction(args)).steps;
+};
+var useGenerateListingTransaction = (params) => {
+  const config = useConfig();
+  const { mutate, mutateAsync, ...result } = useMutation({
+    onSuccess: params.onSuccess,
+    mutationFn: (args) => generateListingTransaction(args, config, params.chainId)
+  });
+  return {
+    ...result,
+    generateListingTransaction: mutate,
+    generateListingTransactionAsync: mutateAsync
+  };
+};
+
+// src/react/hooks/useGenerateOfferTransaction.tsx
+import { useMutation as useMutation2 } from "@tanstack/react-query";
+var dateToUnixTime2 = (date) => Math.floor(date.getTime() / 1e3).toString();
+var generateOfferTransaction = async (params, config, chainId) => {
+  const args = {
+    ...params,
+    offer: { ...params.offer, expiry: dateToUnixTime2(params.offer.expiry) }
+  };
+  const marketplaceClient = getMarketplaceClient(chainId, config);
+  return (await marketplaceClient.generateOfferTransaction(args)).steps;
+};
+var useGenerateOfferTransaction = (params) => {
+  const config = useConfig();
+  const { mutate, mutateAsync, ...result } = useMutation2({
+    onSuccess: params.onSuccess,
+    mutationFn: (args) => generateOfferTransaction(args, config, params.chainId)
+  });
+  return {
+    ...result,
+    generateOfferTransaction: mutate,
+    generateOfferTransactionAsync: mutateAsync
+  };
+};
+
+// src/react/hooks/useTransferTokens.tsx
+import { erc721Abi } from "viem";
+import { useAccount, useWriteContract } from "wagmi";
+var prepareTransferConfig = (params, accountAddress) => {
+  if (params.contractType === "ERC721") {
+    return {
+      abi: erc721Abi,
+      address: params.collectionAddress,
+      functionName: "safeTransferFrom",
+      args: [
+        accountAddress,
+        params.receiverAddress,
+        BigInt(params.tokenId)
+      ]
+    };
+  }
+  return {
+    abi: ERC1155_ABI,
+    address: params.collectionAddress,
+    functionName: "safeTransferFrom",
+    args: [
+      accountAddress,
+      params.receiverAddress,
+      BigInt(params.tokenId),
+      params.quantity,
+      "0x"
+      // data
+    ]
+  };
+};
+var useTransferTokens = () => {
+  const { address: accountAddress } = useAccount();
+  const {
+    writeContractAsync,
+    data: hash,
+    isPending,
+    isError,
+    isSuccess
+  } = useWriteContract();
+  const transferTokensAsync = async (params) => {
+    if (!accountAddress) {
+      throw new Error("No wallet connected");
+    }
+    const config = prepareTransferConfig(params, accountAddress);
+    return await writeContractAsync(config);
+  };
+  return {
+    transferTokensAsync,
+    hash,
+    transferring: isPending,
+    transferFailed: isError,
+    transferSuccess: isSuccess
+  };
+};
+
+export {
+  MarketplaceSdkContext,
+  MarketplaceProvider,
+  useConfig,
+  collectiblesFilterSchema,
+  getCollectibleHighestOfferArgsSchema,
+  listOffersForCollectibleArgsSchema,
+  listCollectiblesArgsSchema,
+  stepSchema,
+  collectibleOptions,
+  useCollectible,
+  collectionOptions,
+  useCollection,
+  currenciesOptions,
+  useCurrencies,
+  metadataOptionsSchema,
+  listBalancesOptions,
+  useListBalances,
+  lowestListingOptions,
+  useLowestListing,
+  marketplaceConfigOptions,
+  useMarketplaceConfig,
+  royaletyPercentageOptions,
+  useRoyaltyPercentage,
+  generateListingTransaction,
+  useGenerateListingTransaction,
+  generateOfferTransaction,
+  useGenerateOfferTransaction,
+  useTransferTokens
+};
+//# sourceMappingURL=chunk-ITJEOCDV.js.map