@0xsequence/marketplace-sdk 0.2.0 → 0.3.0

package/dist/{chunk-5EOVZAKT.js → chunk-BJE7AG6V.js}

@@ -2,12 +2,12 @@
 import {
   getPublicRpcClient
 } from "./chunk-6JWGELXL.js";
-import {
-  EIP2981_ABI
-} from "./chunk-DBFOPEV6.js";
 import {
   ERC1155_ABI
 } from "./chunk-O5JXKTWP.js";
+import {
+  EIP2981_ABI
+} from "./chunk-DBFOPEV6.js";
 import {
   AddressSchema,
   ChainIdSchema,
@@ -44,7 +44,7 @@ import {
   getMarketplaceClient,
   getMetadataClient,
   getQueryClient
-} from "./chunk-GZIA25G4.js";
+} from "./chunk-GZG2QO64.js";
 
 // src/react/hooks/useBalanceOfCollectible.tsx
 import { queryOptions, skipToken, useQuery } from "@tanstack/react-query";
@@ -783,11 +783,44 @@ var useCurrencies = (args) => {
   return useQuery5(currenciesOptions(args, config));
 };
 
-// src/react/hooks/useFilters.tsx
+// src/react/hooks/useCurrency.tsx
 import { queryOptions as queryOptions6, useQuery as useQuery6 } from "@tanstack/react-query";
 import { z as z7 } from "zod";
-var UseFiltersSchema = z7.object({
-  chainId: ChainIdSchema.pipe(z7.coerce.string()),
+var ChainIdCoerce2 = ChainIdSchema.transform((val) => val.toString());
+var UseCurrencyArgsSchema = z7.object({
+  chainId: ChainIdCoerce2,
+  currencyAddress: AddressSchema,
+  query: QueryArgSchema
+});
+var fetchCurrency = async (chainId, currencyAddress, config) => {
+  const parsedChainId = ChainIdCoerce2.parse(chainId);
+  const queryClient = getQueryClient();
+  let currencies = queryClient.getQueryData([...currencyKeys.lists, chainId]);
+  if (!currencies) {
+    const marketplaceClient = getMarketplaceClient(parsedChainId, config);
+    currencies = await marketplaceClient.listCurrencies().then((resp) => resp.currencies);
+  }
+  return currencies?.find(
+    (currency) => currency.contractAddress.toLowerCase() === currencyAddress.toLowerCase()
+  );
+};
+var currencyOptions = (args, config) => {
+  return queryOptions6({
+    ...args.query,
+    queryKey: [...currencyKeys.details, args.chainId, args.currencyAddress],
+    queryFn: () => fetchCurrency(args.chainId, args.currencyAddress, config)
+  });
+};
+var useCurrency = (args) => {
+  const config = useConfig();
+  return useQuery6(currencyOptions(args, config));
+};
+
+// src/react/hooks/useFilters.tsx
+import { queryOptions as queryOptions7, useQuery as useQuery7 } from "@tanstack/react-query";
+import { z as z8 } from "zod";
+var UseFiltersSchema = z8.object({
+  chainId: ChainIdSchema.pipe(z8.coerce.string()),
   collectionAddress: AddressSchema,
   query: QueryArgSchema
 });
@@ -800,7 +833,7 @@ var fetchFilters = async (args, config) => {
   }).then((resp) => resp.filters);
 };
 var filtersOptions = (args, config) => {
-  return queryOptions6({
+  return queryOptions7({
     ...args.query,
     queryKey: [...collectableKeys.filter, args, config],
     queryFn: () => fetchFilters(args, config)
@@ -808,14 +841,14 @@ var filtersOptions = (args, config) => {
 };
 var useFilters = (args) => {
   const config = useConfig();
-  return useQuery6(filtersOptions(args, config));
+  return useQuery7(filtersOptions(args, config));
 };
 
 // src/react/hooks/useFloorOrder.tsx
-import { queryOptions as queryOptions7, useQuery as useQuery7 } from "@tanstack/react-query";
-import { z as z8 } from "zod";
-var UseFloorOrderSchema = z8.object({
-  chainId: ChainIdSchema.pipe(z8.coerce.string()),
+import { queryOptions as queryOptions8, useQuery as useQuery8 } from "@tanstack/react-query";
+import { z as z9 } from "zod";
+var UseFloorOrderSchema = z9.object({
+  chainId: ChainIdSchema.pipe(z9.coerce.string()),
   collectionAddress: AddressSchema,
   query: QueryArgSchema
 });
@@ -824,24 +857,24 @@ var fetchFloorOrder = async (args, config) => {
   return marketplaceClient.getFloorOrder({ contractAddress: args.collectionAddress }).then((data) => data.collectible);
 };
 var floorOrderOptions = (args, config) => {
-  return queryOptions7({
+  return queryOptions8({
     queryKey: [...collectableKeys.floorOrders, args, config],
     queryFn: () => fetchFloorOrder(args, config)
   });
 };
 var useFloorOrder = (args) => {
   const config = useConfig();
-  return useQuery7(floorOrderOptions(args, config));
+  return useQuery8(floorOrderOptions(args, config));
 };
 
 // src/react/hooks/useHighestOffer.tsx
-import { queryOptions as queryOptions8, useQuery as useQuery8 } from "@tanstack/react-query";
-import { z as z9 } from "zod";
+import { queryOptions as queryOptions9, useQuery as useQuery9 } from "@tanstack/react-query";
+import { z as z10 } from "zod";
 var UseHighestOfferArgsSchema = getCollectibleHighestOfferArgsSchema.omit({
   contractAddress: true
 }).extend({
   collectionAddress: AddressSchema,
-  chainId: ChainIdSchema.pipe(z9.coerce.string()),
+  chainId: ChainIdSchema.pipe(z10.coerce.string()),
   query: QueryArgSchema
 });
 var fetchHighestOffer = async (args, config) => {
@@ -853,7 +886,7 @@ var fetchHighestOffer = async (args, config) => {
   });
 };
 var highestOfferOptions = (args, config) => {
-  return queryOptions8({
+  return queryOptions9({
     ...args.query,
     queryKey: [...collectableKeys.highestOffers, args, config],
     queryFn: () => fetchHighestOffer(args, config)
@@ -861,44 +894,44 @@ var highestOfferOptions = (args, config) => {
 };
 var useHighestOffer = (args) => {
   const config = useConfig();
-  return useQuery8(highestOfferOptions(args, config));
+  return useQuery9(highestOfferOptions(args, config));
 };
 
 // src/react/hooks/useListBalances.tsx
 import { SortOrder as SortOrder2 } from "@0xsequence/indexer";
 import { infiniteQueryOptions, useInfiniteQuery } from "@tanstack/react-query";
-import { z as z10 } from "zod";
-var metadataOptionsSchema = z10.object({
-  verifiedOnly: z10.boolean().optional(),
-  unverifiedOnly: z10.boolean().optional(),
-  includeContracts: z10.array(z10.string()).optional()
-});
-var sortOrderSchema2 = z10.nativeEnum(SortOrder2);
-var sortBySchema2 = z10.object({
-  column: z10.string(),
+import { z as z11 } from "zod";
+var metadataOptionsSchema = z11.object({
+  verifiedOnly: z11.boolean().optional(),
+  unverifiedOnly: z11.boolean().optional(),
+  includeContracts: z11.array(z11.string()).optional()
+});
+var sortOrderSchema2 = z11.nativeEnum(SortOrder2);
+var sortBySchema2 = z11.object({
+  column: z11.string(),
   order: sortOrderSchema2
 });
-var pageSchema2 = z10.object({
-  page: z10.number().optional(),
-  column: z10.string().optional(),
-  before: z10.any().optional(),
-  after: z10.any().optional(),
-  sort: z10.array(sortBySchema2).optional(),
-  pageSize: z10.number().optional(),
-  more: z10.boolean().optional()
-});
-var useListBalancesArgsSchema = z10.object({
-  chainId: ChainIdSchema.pipe(z10.coerce.number()),
+var pageSchema2 = z11.object({
+  page: z11.number().optional(),
+  column: z11.string().optional(),
+  before: z11.any().optional(),
+  after: z11.any().optional(),
+  sort: z11.array(sortBySchema2).optional(),
+  pageSize: z11.number().optional(),
+  more: z11.boolean().optional()
+});
+var useListBalancesArgsSchema = z11.object({
+  chainId: ChainIdSchema.pipe(z11.coerce.number()),
   accountAddress: AddressSchema.optional(),
   contractAddress: AddressSchema.optional(),
-  tokenId: z10.string().optional(),
-  includeMetadata: z10.boolean().optional(),
+  tokenId: z11.string().optional(),
+  includeMetadata: z11.boolean().optional(),
   metadataOptions: metadataOptionsSchema.optional(),
-  includeCollectionTokens: z10.boolean().optional(),
+  includeCollectionTokens: z11.boolean().optional(),
   page: pageSchema2.optional(),
   query: QueryArgSchema
 });
-var fetchBalances = async (args, page, config) => {
+var fetchBalances = async (args, config, page) => {
   const parsedArgs = useListBalancesArgsSchema.parse(args);
   const indexerClient = getIndexerClient(parsedArgs.chainId, config);
   return indexerClient.getTokenBalances({
@@ -911,7 +944,7 @@ var listBalancesOptions = (args, config) => {
   return infiniteQueryOptions({
     ...args.query,
     queryKey: [...balanceQueries.lists, args, config],
-    queryFn: ({ pageParam }) => fetchBalances(args, pageParam, config),
+    queryFn: ({ pageParam }) => fetchBalances(args, config, pageParam),
     initialPageParam: { page: 1, pageSize: 30 },
     getNextPageParam: (lastPage) => lastPage.page.after
   });
@@ -923,15 +956,15 @@ var useListBalances = (args) => {
 
 // src/react/hooks/useListCollectibles.tsx
 import { infiniteQueryOptions as infiniteQueryOptions2, useInfiniteQuery as useInfiniteQuery2 } from "@tanstack/react-query";
-import { z as z11 } from "zod";
+import { z as z12 } from "zod";
 var UseListCollectiblesArgsSchema = listCollectiblesArgsSchema.omit({
   contractAddress: true
 }).extend({
   collectionAddress: AddressSchema,
-  chainId: ChainIdSchema.pipe(z11.coerce.string()),
+  chainId: ChainIdSchema.pipe(z12.coerce.string()),
   query: QueryArgSchema
 });
-var fetchCollectibles = async (args, page, marketplaceClient) => {
+var fetchCollectibles = async (args, marketplaceClient, page) => {
   const parsedArgs = UseListCollectiblesArgsSchema.parse(args);
   const arg = {
     ...parsedArgs,
@@ -943,8 +976,8 @@ var fetchCollectibles = async (args, page, marketplaceClient) => {
 var listCollectiblesOptions = (args, config) => {
   const marketplaceClient = getMarketplaceClient(args.chainId, config);
   return infiniteQueryOptions2({
-    queryKey: [...collectableKeys.lists, args, marketplaceClient],
-    queryFn: ({ pageParam }) => fetchCollectibles(args, pageParam, marketplaceClient),
+    queryKey: [...collectableKeys.lists, args],
+    queryFn: ({ pageParam }) => fetchCollectibles(args, marketplaceClient, pageParam),
     initialPageParam: { page: 1, pageSize: 30 },
     getNextPageParam: (lastPage) => lastPage.page?.more ? lastPage.page : void 0
   });
@@ -955,42 +988,71 @@ var useListCollectibles = (args) => {
 };
 
 // src/react/hooks/useListOffersForCollectible.tsx
-import { infiniteQueryOptions as infiniteQueryOptions3, useInfiniteQuery as useInfiniteQuery3 } from "@tanstack/react-query";
-import { z as z12 } from "zod";
+import { queryOptions as queryOptions10, useQuery as useQuery10 } from "@tanstack/react-query";
+import { z as z13 } from "zod";
 var UseListOffersForCollectibleArgsSchema = listOffersForCollectibleArgsSchema.extend({
-  chainId: ChainIdSchema.pipe(z12.coerce.string())
-});
-var fetchListOffersForCollectible = async (config, args, page) => {
+  chainId: ChainIdSchema.pipe(z13.coerce.string()),
+  collectionAddress: z13.string(),
+  collectibleId: z13.string()
+}).omit({ contractAddress: true, tokenId: true });
+var fetchListOffersForCollectible = async (config, args) => {
   const arg = {
-    contractAddress: args.contractAddress,
-    tokenId: args.tokenId,
+    contractAddress: args.collectionAddress,
+    tokenId: args.collectibleId,
     filter: args.filter,
-    page
+    page: args.page
   };
   const marketplaceClient = getMarketplaceClient(args.chainId, config);
   return marketplaceClient.listCollectibleOffers(arg);
 };
 var listOffersForCollectibleOptions = (args, config) => {
-  return infiniteQueryOptions3({
+  return queryOptions10({
     queryKey: [...collectableKeys.offers, args, config],
-    queryFn: ({ pageParam }) => fetchListOffersForCollectible(config, args, pageParam),
-    initialPageParam: { page: 1, pageSize: 30 },
-    getNextPageParam: (lastPage) => lastPage.page?.more ? lastPage.page : void 0
+    queryFn: () => fetchListOffersForCollectible(config, args)
   });
 };
 var useListOffersForCollectible = (args) => {
   const config = useConfig();
-  return useInfiniteQuery3(listOffersForCollectibleOptions(args, config));
+  return useQuery10(listOffersForCollectibleOptions(args, config));
+};
+
+// src/react/hooks/useListListingsForCollectible.tsx
+import { queryOptions as queryOptions11, useQuery as useQuery11 } from "@tanstack/react-query";
+import { z as z14 } from "zod";
+var UseListListingsForCollectibleArgsSchema = listListingsForCollectibleArgsSchema.extend({
+  chainId: ChainIdSchema.pipe(z14.coerce.string()),
+  collectionAddress: z14.string(),
+  collectibleId: z14.string()
+}).omit({ contractAddress: true, tokenId: true });
+var fetchListListingsForCollectible = async (config, args) => {
+  const arg = {
+    contractAddress: args.collectionAddress,
+    tokenId: args.collectibleId,
+    filter: args.filter,
+    page: args.page
+  };
+  const marketplaceClient = getMarketplaceClient(args.chainId, config);
+  return marketplaceClient.listCollectibleListings(arg);
+};
+var listListingsForCollectibleOptions = (args, config) => {
+  return queryOptions11({
+    queryKey: [...collectableKeys.offers, args, config],
+    queryFn: () => fetchListListingsForCollectible(config, args)
+  });
+};
+var useListListingsForCollectible = (args) => {
+  const config = useConfig();
+  return useQuery11(listListingsForCollectibleOptions(args, config));
 };
 
 // src/react/hooks/useLowestListing.tsx
-import { queryOptions as queryOptions9, useQuery as useQuery9 } from "@tanstack/react-query";
-import { z as z13 } from "zod";
+import { queryOptions as queryOptions12, useQuery as useQuery12 } from "@tanstack/react-query";
+import { z as z15 } from "zod";
 var UseLowestListingSchema = getCollectibleLowestListingArgsSchema.omit({
   contractAddress: true
 }).extend({
   collectionAddress: AddressSchema,
-  chainId: ChainIdSchema.pipe(z13.coerce.string()),
+  chainId: ChainIdSchema.pipe(z15.coerce.string()),
   query: QueryArgSchema
 });
 var fetchLowestListing = async (args, config) => {
@@ -1002,7 +1064,7 @@ var fetchLowestListing = async (args, config) => {
   });
 };
 var lowestListingOptions = (args, config) => {
-  return queryOptions9({
+  return queryOptions12({
     ...args.query,
     queryKey: [...collectableKeys.lowestListings, args, config],
     queryFn: () => fetchLowestListing(args, config)
@@ -1010,14 +1072,14 @@ var lowestListingOptions = (args, config) => {
 };
 var useLowestListing = (args) => {
   const config = useConfig();
-  return useQuery9(lowestListingOptions(args, config));
+  return useQuery12(lowestListingOptions(args, config));
 };
 
 // src/react/hooks/useMarketplaceConfig.tsx
-import { useQuery as useQuery10 } from "@tanstack/react-query";
+import { useQuery as useQuery13 } from "@tanstack/react-query";
 
 // src/react/hooks/options/marketplaceConfigOptions.ts
-import { queryOptions as queryOptions10 } from "@tanstack/react-query";
+import { queryOptions as queryOptions13 } from "@tanstack/react-query";
 var fetchBuilderConfig = async (projectId, env) => {
   const url = `${builderMarketplaceApi(projectId, env)}`;
   const response = await fetch(`${url}/config.json`);
@@ -1057,7 +1119,7 @@ var marketplaceConfigOptions = (config) => {
     env = config._internal.builderEnv ?? env;
   }
   const projectId = config.projectId;
-  return queryOptions10({
+  return queryOptions13({
     queryKey: [...configKeys.marketplace, env, projectId],
     queryFn: () => fetchMarketplaceConfig(env, projectId)
   });
@@ -1066,17 +1128,17 @@ var marketplaceConfigOptions = (config) => {
 // src/react/hooks/useMarketplaceConfig.tsx
 var useMarketplaceConfig = () => {
   const config = useConfig();
-  return useQuery10(marketplaceConfigOptions(config));
+  return useQuery13(marketplaceConfigOptions(config));
 };
 
 // src/react/hooks/useRoyaltyPercentage.tsx
-import { queryOptions as queryOptions11, useQuery as useQuery11 } from "@tanstack/react-query";
+import { queryOptions as queryOptions14, useQuery as useQuery14 } from "@tanstack/react-query";
 import { getContract } from "viem";
-import { z as z14 } from "zod";
-var UseRoyaletyPercentageSchema = z14.object({
-  chainId: ChainIdSchema.pipe(z14.coerce.string()),
+import { z as z16 } from "zod";
+var UseRoyaletyPercentageSchema = z16.object({
+  chainId: ChainIdSchema.pipe(z16.coerce.string()),
   collectionAddress: AddressSchema,
-  collectibleId: z14.string(),
+  collectibleId: z16.string(),
   query: QueryArgSchema
 });
 var fetchRoyaletyPercentage = async (args) => {
@@ -1097,13 +1159,13 @@ var fetchRoyaletyPercentage = async (args) => {
     return 0n;
   }
 };
-var royaletyPercentageOptions = (args) => queryOptions11({
+var royaletyPercentageOptions = (args) => queryOptions14({
   ...args.query,
   queryKey: [...collectableKeys.royaltyPercentage, args],
   queryFn: () => fetchRoyaletyPercentage(args)
 });
 var useRoyaltyPercentage = (args) => {
-  return useQuery11(royaletyPercentageOptions(args));
+  return useQuery14(royaletyPercentageOptions(args));
 };
 
 // src/react/hooks/useGenerateListingTransaction.tsx
@@ -1159,13 +1221,13 @@ var useGenerateOfferTransaction = (params) => {
 
 // src/react/hooks/useGenerateSellTransaction.tsx
 import { useMutation as useMutation3 } from "@tanstack/react-query";
-import { z as z15 } from "zod";
-var UserGeneratSellTransactionArgsSchema = z15.object({
-  chainId: ChainIdSchema.pipe(z15.coerce.string()),
-  onSuccess: z15.function().args(stepSchema.array().optional()).optional()
+import { z as z17 } from "zod";
+var UserGeneratSellTransactionArgsSchema = z17.object({
+  chainId: ChainIdSchema.pipe(z17.coerce.string()),
+  onSuccess: z17.function().args(stepSchema.array().optional()).optional()
 });
 var generateSellTransaction = async (args, config, chainId) => {
-  const parsedChainId = ChainIdSchema.pipe(z15.coerce.string()).parse(chainId);
+  const parsedChainId = ChainIdSchema.pipe(z17.coerce.string()).parse(chainId);
   const marketplaceClient = getMarketplaceClient(parsedChainId, config);
   return marketplaceClient.generateSellTransaction(args).then((data) => data.steps);
 };
@@ -1238,17 +1300,17 @@ var useTransferTokens = () => {
 };
 
 // src/react/hooks/useCheckoutOptions.tsx
-import { queryOptions as queryOptions12, useQuery as useQuery12 } from "@tanstack/react-query";
-import { z as z16 } from "zod";
-var UseCheckoutOptionsSchema = z16.object({
-  chainId: ChainIdSchema.pipe(z16.coerce.string()),
+import { queryOptions as queryOptions15, useQuery as useQuery15 } from "@tanstack/react-query";
+import { z as z18 } from "zod";
+var UseCheckoutOptionsSchema = z18.object({
+  chainId: ChainIdSchema.pipe(z18.coerce.string()),
   walletAddress: AddressSchema,
-  orders: z16.array(
-    z16.object({
+  orders: z18.array(
+    z18.object({
       collectionAddress: AddressSchema,
-      orderId: z16.string(),
-      quantity: z16.number(),
-      marketplace: z16.nativeEnum(MarketplaceKind)
+      orderId: z18.string(),
+      quantity: z18.number(),
+      marketplace: z18.nativeEnum(MarketplaceKind)
     })
   ),
   query: QueryArgSchema
@@ -1268,14 +1330,62 @@ var fetchCheckoutOptions = async (args, config) => {
   });
 };
 var checkoutOptionsOptions = (args, config) => {
-  return queryOptions12({
+  return queryOptions15({
     queryKey: ["checkoutOptions", args],
     queryFn: () => fetchCheckoutOptions(args, config)
   });
 };
 var useCheckoutOptions = (args) => {
   const config = useConfig();
-  return useQuery12(checkoutOptionsOptions(args, config));
+  return useQuery15(checkoutOptionsOptions(args, config));
+};
+
+// src/react/hooks/useListCollections.tsx
+import { queryOptions as queryOptions16, useQuery as useQuery16 } from "@tanstack/react-query";
+import { z as z19 } from "zod";
+var UseListCollectionsSchema = z19.object({
+  query: QueryArgSchema.optional().default({})
+});
+var fetchListCollections = async ({ marketplaceConfig }, config) => {
+  const metadataClient = getMetadataClient(config);
+  if (!marketplaceConfig?.collections?.length) {
+    return [];
+  }
+  const collectionsByChain = marketplaceConfig.collections.reduce((acc, curr) => {
+    const { chainId, collectionAddress } = curr;
+    if (!acc[chainId]) {
+      acc[chainId] = [];
+    }
+    acc[chainId].push(collectionAddress);
+    return acc;
+  }, {});
+  const promises = Object.entries(collectionsByChain).map(
+    ([chainId, addresses]) => metadataClient.getContractInfoBatch({
+      chainID: chainId,
+      contractAddresses: addresses
+    }).then((resp) => Object.values(resp.contractInfoMap))
+  );
+  const results = await Promise.all(promises);
+  return results.flat();
+};
+var listCollectionsOptions = (args, config) => {
+  return queryOptions16({
+    ...args.query,
+    queryKey: [...collectionKeys.list],
+    queryFn: () => fetchListCollections(args, config)
+  });
+};
+var useListCollections = (args = {}) => {
+  const config = useConfig();
+  const { data: marketplaceConfig, isLoading: isLoadingConfig } = useMarketplaceConfig();
+  return useQuery16({
+    ...listCollectionsOptions(
+      // biome-ignore lint/style/noNonNullAssertion: <explanation>
+      { marketplaceConfig, query: args.query },
+      config
+    ),
+    enabled: !isLoadingConfig && !!marketplaceConfig
+  });
 };
 
 export {
@@ -1292,6 +1402,8 @@ export {
   useCollection,
   currenciesOptions,
   useCurrencies,
+  currencyOptions,
+  useCurrency,
   fetchFilters,
   filtersOptions,
   useFilters,
@@ -1306,6 +1418,8 @@ export {
   useListCollectibles,
   listOffersForCollectibleOptions,
   useListOffersForCollectible,
+  listListingsForCollectibleOptions,
+  useListListingsForCollectible,
   lowestListingOptions,
   useLowestListing,
   marketplaceConfigOptions,
@@ -1320,6 +1434,8 @@ export {
   useGenerateSellTransaction,
   useTransferTokens,
   checkoutOptionsOptions,
-  useCheckoutOptions
+  useCheckoutOptions,
+  listCollectionsOptions,
+  useListCollections
 };
-//# sourceMappingURL=chunk-5EOVZAKT.js.map
+//# sourceMappingURL=chunk-BJE7AG6V.js.map