@net-protocol/bazaar 0.1.1 → 0.1.3

package/dist/index.js

@@ -359,10 +359,11 @@ var DEFAULT_FEE_COLLECTOR_ADDRESS = "0x32D16C15410248bef498D7aF50D10Db1a546b9E5"
 var DEFAULT_ERC20_BAZAAR_ADDRESS = "0x00000000a2d173a4610c85c7471a25b6bc216a70";
 var DEFAULT_NFT_FEE_BPS = 500;
 var BULK_SEAPORT_ORDER_STATUS_FETCHER_ADDRESS = "0x0000009112ABCE652674b4fE3eD9C765B22d11A7";
-var ERC721_OWNER_OF_HELPER_ADDRESS = "0x000000aa4eFa2e5A4a6002C7F08B6e8Ec8cf1dDa";
-var ERC20_BULK_BALANCE_CHECKER_ADDRESS = "0x000000b50a9f2923f2db931391824f6d1278f712";
+var ERC721_OWNER_OF_HELPER_ADDRESS = "0x00000012E3eb0700925947fAF9cd1440319b4F37";
+var ERC20_BULK_BALANCE_CHECKER_ADDRESS = "0x000000B50A9f2923F2DB931391824F6D1278f712";
 var NET_SEAPORT_ZONE_ADDRESS = "0x000000007F8c58fbf215bF91Bda7421A806cf3ae";
 var NET_SEAPORT_COLLECTION_OFFER_ZONE_ADDRESS = "0x000000B799ec6D7aCC1B578f62bFc324c25DFC5A";
+var NET_SEAPORT_PRIVATE_ORDER_ZONE_ADDRESS = "0x000000bC63761cbb05305632212e2f3AE2BE7a9B";
 var BAZAAR_CHAIN_CONFIGS = {
   // Base Mainnet
   8453: {
@@ -650,18 +651,26 @@ async function bulkFetchOrderStatuses(client, chainId, orderHashes) {
     return [];
   }
   const seaportAddress = getSeaportAddress(chainId);
-  const results = await actions.readContract(client, {
-    address: BULK_SEAPORT_ORDER_STATUS_FETCHER_ADDRESS,
-    abi: BULK_SEAPORT_ORDER_STATUS_FETCHER_ABI,
-    functionName: "getOrderStatuses",
-    args: [seaportAddress, orderHashes]
-  });
-  return results.map((r) => ({
-    isValidated: r.isValidated,
-    isCancelled: r.isCancelled,
-    totalFilled: BigInt(r.totalFilled),
-    totalSize: BigInt(r.totalSize)
-  }));
+  try {
+    console.log(`[bulkFetchOrderStatuses] fetching ${orderHashes.length} statuses via ${BULK_SEAPORT_ORDER_STATUS_FETCHER_ADDRESS}`);
+    const results = await actions.readContract(client, {
+      address: BULK_SEAPORT_ORDER_STATUS_FETCHER_ADDRESS,
+      abi: BULK_SEAPORT_ORDER_STATUS_FETCHER_ABI,
+      functionName: "getOrderStatuses",
+      args: [seaportAddress, orderHashes]
+    });
+    const statuses = results.map((r) => ({
+      isValidated: r.isValidated,
+      isCancelled: r.isCancelled,
+      totalFilled: BigInt(r.totalFilled),
+      totalSize: BigInt(r.totalSize)
+    }));
+    console.log(`[bulkFetchOrderStatuses] success: ${statuses.length} statuses`);
+    return statuses;
+  } catch (err) {
+    console.error(`[bulkFetchOrderStatuses] FAILED for ${orderHashes.length} hashes:`, err);
+    throw err;
+  }
 }
 async function createOrderStatusMap(client, chainId, orderHashes) {
   const statuses = await bulkFetchOrderStatuses(client, chainId, orderHashes);
@@ -676,16 +685,21 @@ async function bulkFetchNftOwners(client, nftAddress, tokenIds) {
     return [];
   }
   try {
+    console.log(`[bulkFetchNftOwners] fetching ${tokenIds.length} owners for ${nftAddress.slice(0, 10)} via ${ERC721_OWNER_OF_HELPER_ADDRESS}`);
     const owners = await actions.readContract(client, {
       address: ERC721_OWNER_OF_HELPER_ADDRESS,
       abi: ERC721_OWNER_OF_HELPER_ABI,
       functionName: "getTokenOwners",
       args: [nftAddress, tokenIds.map((id) => BigInt(id))]
     });
-    return owners.map(
+    const result = owners.map(
       (owner) => owner === "0x0000000000000000000000000000000000000000" ? null : owner
     );
-  } catch {
+    const validCount = result.filter((o) => o !== null).length;
+    console.log(`[bulkFetchNftOwners] success: ${validCount}/${tokenIds.length} have owners`);
+    return result;
+  } catch (err) {
+    console.error(`[bulkFetchNftOwners] FAILED for ${tokenIds.length} tokens \u2014 returning all null:`, err);
     return tokenIds.map(() => null);
   }
 }
@@ -702,14 +716,18 @@ async function bulkFetchErc20Balances(client, tokenAddress, addresses) {
     return [];
   }
   try {
+    console.log(`[bulkFetchErc20Balances] fetching ${addresses.length} balances for ${tokenAddress.slice(0, 10)}`);
     const balances = await actions.readContract(client, {
       address: ERC20_BULK_BALANCE_CHECKER_ADDRESS,
       abi: ERC20_BULK_BALANCE_CHECKER_ABI,
       functionName: "getBalances",
       args: [tokenAddress, addresses]
     });
-    return balances.map((b) => BigInt(b));
-  } catch {
+    const result = balances.map((b) => BigInt(b));
+    console.log(`[bulkFetchErc20Balances] success: ${result.length} balances`);
+    return result;
+  } catch (err) {
+    console.error(`[bulkFetchErc20Balances] FAILED for ${addresses.length} addresses \u2014 returning all zero:`, err);
     return addresses.map(() => BigInt(0));
   }
 }
@@ -788,6 +806,7 @@ function parseListingFromMessage(message, chainId) {
     }
     const priceWei = getTotalConsiderationAmount(parameters);
     const tokenId = offerItem.identifierOrCriteria.toString();
+    const targetFulfiller = parameters.zone.toLowerCase() === NET_SEAPORT_PRIVATE_ORDER_ZONE_ADDRESS.toLowerCase() && parameters.zoneHash !== "0x0000000000000000000000000000000000000000000000000000000000000000" ? parameters.zoneHash : void 0;
     return {
       maker: parameters.offerer,
       nftAddress: offerItem.token,
@@ -804,7 +823,8 @@ function parseListingFromMessage(message, chainId) {
       orderComponents: {
         ...parameters,
         counter: submission.counter
-      }
+      },
+      targetFulfiller
     };
   } catch {
     return null;
@@ -1014,26 +1034,30 @@ var BazaarClient = class {
     }
     this.chainId = params.chainId;
     this.rpcUrl = params.rpcUrl || CHAIN_RPC_URLS[params.chainId]?.[0] || "";
-    if (!this.rpcUrl) {
-      throw new Error(`No RPC URL available for chain ${params.chainId}`);
+    if (params.publicClient) {
+      this.client = params.publicClient;
+    } else {
+      if (!this.rpcUrl) {
+        throw new Error(`No RPC URL available for chain ${params.chainId}`);
+      }
+      const config = getBazaarChainConfig(params.chainId);
+      this.client = viem.createPublicClient({
+        chain: viem.defineChain({
+          id: params.chainId,
+          name: `Chain ${params.chainId}`,
+          nativeCurrency: {
+            name: config.wrappedNativeCurrency.name.replace("Wrapped ", ""),
+            symbol: config.currencySymbol.toUpperCase(),
+            decimals: 18
+          },
+          rpcUrls: {
+            default: { http: [this.rpcUrl] }
+          }
+        }),
+        transport: viem.http(this.rpcUrl),
+        batch: { multicall: true }
+      });
     }
-    const config = getBazaarChainConfig(params.chainId);
-    this.client = viem.createPublicClient({
-      chain: viem.defineChain({
-        id: params.chainId,
-        name: `Chain ${params.chainId}`,
-        nativeCurrency: {
-          name: config.wrappedNativeCurrency.name.replace("Wrapped ", ""),
-          symbol: config.currencySymbol.toUpperCase(),
-          decimals: 18
-        },
-        rpcUrls: {
-          default: { http: [this.rpcUrl] }
-        }
-      }),
-      transport: viem.http(this.rpcUrl),
-      batch: { multicall: true }
-    });
     this.netClient = new core.NetClient({
       chainId: params.chainId,
       overrides: params.rpcUrl ? { rpcUrls: [params.rpcUrl] } : void 0
@@ -1050,26 +1074,42 @@ var BazaarClient = class {
    * Results are deduplicated (one per token) and sorted by price (lowest first)
    */
   async getListings(options) {
-    const { nftAddress, excludeMaker, maxMessages = 200 } = options;
+    const { nftAddress, excludeMaker, maker, maxMessages = 200 } = options;
     const bazaarAddress = getBazaarAddress(this.chainId);
-    const count = await this.netClient.getMessageCount({
-      filter: {
-        appAddress: bazaarAddress,
-        topic: nftAddress.toLowerCase()
+    const filter = {
+      appAddress: bazaarAddress,
+      topic: nftAddress.toLowerCase(),
+      maker
+    };
+    let startIndex;
+    let endIndex;
+    if (options.startIndex != null && options.endIndex != null) {
+      startIndex = options.startIndex;
+      endIndex = options.endIndex;
+    } else {
+      const count = await this.netClient.getMessageCount({ filter });
+      if (count === 0) {
+        return [];
       }
-    });
-    if (count === 0) {
-      return [];
+      startIndex = Math.max(0, count - maxMessages);
+      endIndex = count;
     }
-    const startIndex = Math.max(0, count - maxMessages);
     const messages = await this.netClient.getMessages({
-      filter: {
-        appAddress: bazaarAddress,
-        topic: nftAddress.toLowerCase()
-      },
+      filter,
       startIndex,
-      endIndex: count
+      endIndex
     });
+    return this.processListingsFromMessages(messages, options);
+  }
+  /**
+   * Process pre-fetched messages into valid NFT listings.
+   *
+   * Use this when messages have already been fetched (e.g. via useNetMessages)
+   * to avoid redundant RPC calls.
+   */
+  async processListingsFromMessages(messages, options) {
+    const { nftAddress, excludeMaker, includeExpired = false } = options;
+    const tag = `[BazaarClient.processListings chain=${this.chainId}]`;
     let listings = [];
     for (const message of messages) {
       const listing = parseListingFromMessage(message, this.chainId);
@@ -1079,6 +1119,7 @@ var BazaarClient = class {
       }
       listings.push(listing);
     }
+    console.log(tag, `parsed ${listings.length}/${messages.length} messages into listings`);
     if (listings.length === 0) {
       return [];
     }
@@ -1093,15 +1134,27 @@ var BazaarClient = class {
       const statusInfo = statusInfos[index];
       listing.orderStatus = getOrderStatusFromInfo(listing.orderComponents, statusInfo);
     });
+    const statusCounts = {};
+    const now = Math.floor(Date.now() / 1e3);
+    let expiredCount = 0;
+    for (const l of listings) {
+      statusCounts[l.orderStatus] = (statusCounts[l.orderStatus] || 0) + 1;
+      if (l.expirationDate <= now) expiredCount++;
+    }
+    console.log(tag, `order statuses:`, statusCounts, `expired: ${expiredCount}`);
     listings = listings.filter(
-      (l) => l.orderStatus === 2 /* OPEN */ && l.expirationDate > Math.floor(Date.now() / 1e3)
+      (l) => l.orderStatus === 2 /* OPEN */ && l.expirationDate > now || includeExpired && l.orderStatus === 1 /* EXPIRED */
     );
+    console.log(tag, `after status filter: ${listings.length} (OPEN${includeExpired ? " + EXPIRED" : ""})`);
     if (listings.length === 0) {
       return [];
     }
-    const tokenIds = listings.map((l) => l.tokenId);
+    const openListings = listings.filter((l) => l.orderStatus === 2 /* OPEN */);
+    const expiredListings = includeExpired ? listings.filter((l) => l.orderStatus === 1 /* EXPIRED */) : [];
+    const tokenIds = openListings.map((l) => l.tokenId);
     const owners = await bulkFetchNftOwners(this.client, nftAddress, tokenIds);
-    listings = listings.filter((listing, index) => {
+    const beforeOwnership = openListings.length;
+    const validOpenListings = openListings.filter((listing, index) => {
       const owner = owners[index];
       return isListingValid(
         listing.orderStatus,
@@ -1110,7 +1163,16 @@ var BazaarClient = class {
         owner
       );
     });
-    return sortListingsByPrice(getBestListingPerToken(listings));
+    console.log(tag, `after ownership filter: ${validOpenListings.length}/${beforeOwnership} (${beforeOwnership - validOpenListings.length} dropped)`);
+    const dedupedOpen = sortListingsByPrice(getBestListingPerToken(validOpenListings));
+    const activeTokenKeys = new Set(dedupedOpen.map((l) => `${l.nftAddress.toLowerCase()}-${l.tokenId}`));
+    const uniqueExpired = getBestListingPerToken(
+      expiredListings.filter((l) => !activeTokenKeys.has(`${l.nftAddress.toLowerCase()}-${l.tokenId}`))
+    );
+    const sortedExpired = sortListingsByPrice(uniqueExpired);
+    const result = [...dedupedOpen, ...sortedExpired];
+    console.log(tag, `final: ${result.length} listings (${dedupedOpen.length} open, ${sortedExpired.length} expired)`);
+    return result;
   }
   /**
    * Get valid collection offers for a collection
@@ -1125,10 +1187,6 @@ var BazaarClient = class {
   async getCollectionOffers(options) {
     const { nftAddress, excludeMaker, maxMessages = 100 } = options;
     const collectionOffersAddress = getCollectionOffersAddress(this.chainId);
-    const weth = getWrappedNativeCurrency(this.chainId);
-    if (!weth) {
-      return [];
-    }
     const count = await this.netClient.getMessageCount({
       filter: {
         appAddress: collectionOffersAddress,
@@ -1147,6 +1205,21 @@ var BazaarClient = class {
       startIndex,
       endIndex: count
     });
+    return this.processCollectionOffersFromMessages(messages, options);
+  }
+  /**
+   * Process pre-fetched messages into valid collection offers.
+   *
+   * Use this when messages have already been fetched (e.g. via useNetMessages)
+   * to avoid redundant RPC calls.
+   */
+  async processCollectionOffersFromMessages(messages, options) {
+    const { nftAddress, excludeMaker } = options;
+    const tag = `[BazaarClient.processCollectionOffers chain=${this.chainId}]`;
+    const weth = getWrappedNativeCurrency(this.chainId);
+    if (!weth) {
+      return [];
+    }
     let offers = [];
     for (const message of messages) {
       const offer = parseCollectionOfferFromMessage(message, this.chainId);
@@ -1161,6 +1234,7 @@ var BazaarClient = class {
       }
       offers.push(offer);
     }
+    console.log(tag, `parsed ${offers.length}/${messages.length} messages into offers`);
     if (offers.length === 0) {
       return [];
     }
@@ -1175,9 +1249,11 @@ var BazaarClient = class {
       const statusInfo = statusInfos[index];
       offer.orderStatus = getOrderStatusFromInfo(offer.orderComponents, statusInfo);
     });
+    const now = Math.floor(Date.now() / 1e3);
     offers = offers.filter(
-      (o) => o.orderStatus === 2 /* OPEN */ && o.expirationDate > Math.floor(Date.now() / 1e3)
+      (o) => o.orderStatus === 2 /* OPEN */ && o.expirationDate > now
     );
+    console.log(tag, `after status filter: ${offers.length} OPEN & not expired`);
     if (offers.length === 0) {
       return [];
     }
@@ -1187,6 +1263,7 @@ var BazaarClient = class {
     uniqueMakers.forEach((maker, index) => {
       balanceMap.set(maker.toLowerCase(), balances[index]);
     });
+    const beforeBalance = offers.length;
     offers = offers.filter((offer) => {
       const balance = balanceMap.get(offer.maker.toLowerCase()) || BigInt(0);
       return isCollectionOfferValid(
@@ -1196,6 +1273,7 @@ var BazaarClient = class {
         balance
       );
     });
+    console.log(tag, `after balance filter: ${offers.length}/${beforeBalance} (${beforeBalance - offers.length} dropped)`);
     return sortOffersByPrice(offers);
   }
   /**
@@ -1213,8 +1291,7 @@ var BazaarClient = class {
   async getErc20Offers(options) {
     const { tokenAddress, excludeMaker, maxMessages = 200 } = options;
     const erc20OffersAddress = getErc20OffersAddress(this.chainId);
-    const weth = getWrappedNativeCurrency(this.chainId);
-    if (!erc20OffersAddress || !weth) {
+    if (!erc20OffersAddress) {
       return [];
     }
     const count = await this.netClient.getMessageCount({
@@ -1235,6 +1312,21 @@ var BazaarClient = class {
       startIndex,
       endIndex: count
     });
+    return this.processErc20OffersFromMessages(messages, options);
+  }
+  /**
+   * Process pre-fetched messages into valid ERC20 offers.
+   *
+   * Use this when messages have already been fetched (e.g. via useNetMessages)
+   * to avoid redundant RPC calls.
+   */
+  async processErc20OffersFromMessages(messages, options) {
+    const { tokenAddress, excludeMaker } = options;
+    const tag = `[BazaarClient.processErc20Offers chain=${this.chainId}]`;
+    const weth = getWrappedNativeCurrency(this.chainId);
+    if (!weth) {
+      return [];
+    }
     let offers = [];
     for (const message of messages) {
       const offer = parseErc20OfferFromMessage(message, this.chainId);
@@ -1252,6 +1344,7 @@ var BazaarClient = class {
       }
       offers.push(offer);
     }
+    console.log(tag, `parsed ${offers.length}/${messages.length} messages into offers`);
     if (offers.length === 0) {
       return [];
     }
@@ -1266,9 +1359,11 @@ var BazaarClient = class {
       const statusInfo = statusInfos[index];
       offer.orderStatus = getOrderStatusFromInfo(offer.orderComponents, statusInfo);
     });
+    const now = Math.floor(Date.now() / 1e3);
     offers = offers.filter(
-      (o) => o.orderStatus === 2 /* OPEN */ && o.expirationDate > Math.floor(Date.now() / 1e3)
+      (o) => o.orderStatus === 2 /* OPEN */ && o.expirationDate > now
     );
+    console.log(tag, `after status filter: ${offers.length} OPEN & not expired`);
     if (offers.length === 0) {
       return [];
     }
@@ -1278,6 +1373,7 @@ var BazaarClient = class {
     uniqueMakers.forEach((maker, index) => {
       balanceMap.set(maker.toLowerCase(), balances[index]);
     });
+    const beforeBalance = offers.length;
     offers = offers.filter((offer) => {
       const balance = balanceMap.get(offer.maker.toLowerCase()) || BigInt(0);
       return isErc20OfferValid(
@@ -1287,6 +1383,7 @@ var BazaarClient = class {
         balance
       );
     });
+    console.log(tag, `after balance filter: ${offers.length}/${beforeBalance} (${beforeBalance - offers.length} dropped)`);
     return sortErc20OffersByPricePerToken(offers);
   }
   /**
@@ -1301,26 +1398,42 @@ var BazaarClient = class {
    * all valid listings are returned (grouped by maker in the UI).
    */
   async getErc20Listings(options) {
-    const { tokenAddress, excludeMaker, maxMessages = 200 } = options;
+    const { tokenAddress, excludeMaker, maker, maxMessages = 200 } = options;
     const erc20BazaarAddress = getErc20BazaarAddress(this.chainId);
-    const count = await this.netClient.getMessageCount({
-      filter: {
-        appAddress: erc20BazaarAddress,
-        topic: tokenAddress.toLowerCase()
+    const filter = {
+      appAddress: erc20BazaarAddress,
+      topic: tokenAddress.toLowerCase(),
+      maker
+    };
+    let startIndex;
+    let endIndex;
+    if (options.startIndex != null && options.endIndex != null) {
+      startIndex = options.startIndex;
+      endIndex = options.endIndex;
+    } else {
+      const count = await this.netClient.getMessageCount({ filter });
+      if (count === 0) {
+        return [];
       }
-    });
-    if (count === 0) {
-      return [];
+      startIndex = Math.max(0, count - maxMessages);
+      endIndex = count;
     }
-    const startIndex = Math.max(0, count - maxMessages);
     const messages = await this.netClient.getMessages({
-      filter: {
-        appAddress: erc20BazaarAddress,
-        topic: tokenAddress.toLowerCase()
-      },
+      filter,
       startIndex,
-      endIndex: count
+      endIndex
     });
+    return this.processErc20ListingsFromMessages(messages, options);
+  }
+  /**
+   * Process pre-fetched messages into valid ERC20 listings.
+   *
+   * Use this when messages have already been fetched (e.g. via useNetMessages)
+   * to avoid redundant RPC calls.
+   */
+  async processErc20ListingsFromMessages(messages, options) {
+    const { tokenAddress, excludeMaker } = options;
+    const tag = `[BazaarClient.processErc20Listings chain=${this.chainId}]`;
     let listings = [];
     for (const message of messages) {
       const listing = parseErc20ListingFromMessage(message, this.chainId);
@@ -1333,6 +1446,7 @@ var BazaarClient = class {
       }
       listings.push(listing);
     }
+    console.log(tag, `parsed ${listings.length}/${messages.length} messages into listings`);
     if (listings.length === 0) {
       return [];
     }
@@ -1347,9 +1461,18 @@ var BazaarClient = class {
       const statusInfo = statusInfos[index];
       listing.orderStatus = getOrderStatusFromInfo(listing.orderComponents, statusInfo);
     });
+    const statusCounts = {};
+    const now = Math.floor(Date.now() / 1e3);
+    let expiredCount = 0;
+    for (const l of listings) {
+      statusCounts[l.orderStatus] = (statusCounts[l.orderStatus] || 0) + 1;
+      if (l.expirationDate <= now) expiredCount++;
+    }
+    console.log(tag, `order statuses:`, statusCounts, `expired: ${expiredCount}`);
     listings = listings.filter(
-      (l) => l.orderStatus === 2 /* OPEN */ && l.expirationDate > Math.floor(Date.now() / 1e3)
+      (l) => l.orderStatus === 2 /* OPEN */ && l.expirationDate > now
     );
+    console.log(tag, `after status filter: ${listings.length} OPEN & not expired`);
     if (listings.length === 0) {
       return [];
     }
@@ -1359,6 +1482,7 @@ var BazaarClient = class {
     uniqueMakers.forEach((maker, index) => {
       balanceMap.set(maker.toLowerCase(), balances[index]);
     });
+    const beforeBalance = listings.length;
     listings = listings.filter((listing) => {
       const balance = balanceMap.get(listing.maker.toLowerCase()) || BigInt(0);
       return isErc20ListingValid(
@@ -1368,6 +1492,7 @@ var BazaarClient = class {
         balance
       );
     });
+    console.log(tag, `after balance filter: ${listings.length}/${beforeBalance} (${beforeBalance - listings.length} dropped)`);
     return sortErc20ListingsByPricePerToken(listings);
   }
   /**
@@ -1497,6 +1622,7 @@ exports.ERC721_OWNER_OF_HELPER_ABI = ERC721_OWNER_OF_HELPER_ABI;
 exports.ERC721_OWNER_OF_HELPER_ADDRESS = ERC721_OWNER_OF_HELPER_ADDRESS;
 exports.ItemType = ItemType;
 exports.NET_SEAPORT_COLLECTION_OFFER_ZONE_ADDRESS = NET_SEAPORT_COLLECTION_OFFER_ZONE_ADDRESS;
+exports.NET_SEAPORT_PRIVATE_ORDER_ZONE_ADDRESS = NET_SEAPORT_PRIVATE_ORDER_ZONE_ADDRESS;
 exports.NET_SEAPORT_ZONE_ADDRESS = NET_SEAPORT_ZONE_ADDRESS;
 exports.OrderType = OrderType;
 exports.SEAPORT_CANCEL_ABI = SEAPORT_CANCEL_ABI;