@net-protocol/bazaar 0.1.0

package/dist/react.mjs

@@ -0,0 +1,1393 @@
+import { useState, useMemo, useEffect } from 'react';
+import { useNetMessageCount, useNetMessages } from '@net-protocol/core/react';
+import { createPublicClient, http, defineChain, decodeAbiParameters, formatEther } from 'viem';
+import { NetClient } from '@net-protocol/core';
+import { Seaport } from '@opensea/seaport-js';
+import { ethers } from 'ethers';
+import { readContract } from 'viem/actions';
+
+// src/hooks/useBazaarListings.ts
+
+// src/abis/helpers.ts
+var BULK_SEAPORT_ORDER_STATUS_FETCHER_ABI = [
+  { type: "constructor", inputs: [], stateMutability: "nonpayable" },
+  {
+    type: "function",
+    name: "getOrderStatuses",
+    inputs: [
+      { name: "seaport", type: "address", internalType: "address" },
+      { name: "orderHashes", type: "bytes32[]", internalType: "bytes32[]" }
+    ],
+    outputs: [
+      {
+        name: "results",
+        type: "tuple[]",
+        internalType: "struct BulkSeaportOrderStatusFetcher.OrderStatusInfo[]",
+        components: [
+          { name: "isValidated", type: "bool", internalType: "bool" },
+          { name: "isCancelled", type: "bool", internalType: "bool" },
+          { name: "totalFilled", type: "uint256", internalType: "uint256" },
+          { name: "totalSize", type: "uint256", internalType: "uint256" }
+        ]
+      }
+    ],
+    stateMutability: "view"
+  }
+];
+var ERC721_OWNER_OF_HELPER_ABI = [
+  {
+    type: "function",
+    name: "getTokenOwners",
+    inputs: [
+      { name: "nftContract", type: "address", internalType: "address" },
+      { name: "tokenIds", type: "uint256[]", internalType: "uint256[]" }
+    ],
+    outputs: [
+      { name: "owners", type: "address[]", internalType: "address[]" }
+    ],
+    stateMutability: "view"
+  },
+  { type: "error", name: "InvalidAddress", inputs: [] },
+  { type: "error", name: "TokenQueryFailed", inputs: [] }
+];
+var ERC20_BULK_BALANCE_CHECKER_ABI = [
+  {
+    type: "function",
+    name: "getBalances",
+    inputs: [
+      { name: "token", type: "address", internalType: "address" },
+      { name: "addresses", type: "address[]", internalType: "address[]" }
+    ],
+    outputs: [
+      { name: "balances", type: "uint256[]", internalType: "uint256[]" }
+    ],
+    stateMutability: "view"
+  }
+];
+
+// src/abis/seaport.ts
+var SEAPORT_CANCEL_ABI = [
+  {
+    inputs: [
+      {
+        components: [
+          { internalType: "address", name: "offerer", type: "address" },
+          { internalType: "address", name: "zone", type: "address" },
+          {
+            components: [
+              { internalType: "enum ItemType", name: "itemType", type: "uint8" },
+              { internalType: "address", name: "token", type: "address" },
+              { internalType: "uint256", name: "identifierOrCriteria", type: "uint256" },
+              { internalType: "uint256", name: "startAmount", type: "uint256" },
+              { internalType: "uint256", name: "endAmount", type: "uint256" }
+            ],
+            internalType: "struct OfferItem[]",
+            name: "offer",
+            type: "tuple[]"
+          },
+          {
+            components: [
+              { internalType: "enum ItemType", name: "itemType", type: "uint8" },
+              { internalType: "address", name: "token", type: "address" },
+              { internalType: "uint256", name: "identifierOrCriteria", type: "uint256" },
+              { internalType: "uint256", name: "startAmount", type: "uint256" },
+              { internalType: "uint256", name: "endAmount", type: "uint256" },
+              { internalType: "address payable", name: "recipient", type: "address" }
+            ],
+            internalType: "struct ConsiderationItem[]",
+            name: "consideration",
+            type: "tuple[]"
+          },
+          { internalType: "enum OrderType", name: "orderType", type: "uint8" },
+          { internalType: "uint256", name: "startTime", type: "uint256" },
+          { internalType: "uint256", name: "endTime", type: "uint256" },
+          { internalType: "bytes32", name: "zoneHash", type: "bytes32" },
+          { internalType: "uint256", name: "salt", type: "uint256" },
+          { internalType: "bytes32", name: "conduitKey", type: "bytes32" },
+          { internalType: "uint256", name: "counter", type: "uint256" }
+        ],
+        internalType: "struct OrderComponents[]",
+        name: "orders",
+        type: "tuple[]"
+      }
+    ],
+    name: "cancel",
+    outputs: [{ internalType: "bool", name: "cancelled", type: "bool" }],
+    stateMutability: "nonpayable",
+    type: "function"
+  }
+];
+
+// src/abis/index.ts
+var BAZAAR_SUBMISSION_ABI = [
+  {
+    name: "submission",
+    type: "tuple",
+    internalType: "struct BazaarV2.Submission",
+    components: [
+      {
+        name: "parameters",
+        type: "tuple",
+        internalType: "struct OrderParameters",
+        components: [
+          { name: "offerer", type: "address", internalType: "address" },
+          { name: "zone", type: "address", internalType: "address" },
+          {
+            name: "offer",
+            type: "tuple[]",
+            internalType: "struct OfferItem[]",
+            components: [
+              { name: "itemType", type: "uint8", internalType: "enum ItemType" },
+              { name: "token", type: "address", internalType: "address" },
+              { name: "identifierOrCriteria", type: "uint256", internalType: "uint256" },
+              { name: "startAmount", type: "uint256", internalType: "uint256" },
+              { name: "endAmount", type: "uint256", internalType: "uint256" }
+            ]
+          },
+          {
+            name: "consideration",
+            type: "tuple[]",
+            internalType: "struct ConsiderationItem[]",
+            components: [
+              { name: "itemType", type: "uint8", internalType: "enum ItemType" },
+              { name: "token", type: "address", internalType: "address" },
+              { name: "identifierOrCriteria", type: "uint256", internalType: "uint256" },
+              { name: "startAmount", type: "uint256", internalType: "uint256" },
+              { name: "endAmount", type: "uint256", internalType: "uint256" },
+              { name: "recipient", type: "address", internalType: "address payable" }
+            ]
+          },
+          { name: "orderType", type: "uint8", internalType: "enum OrderType" },
+          { name: "startTime", type: "uint256", internalType: "uint256" },
+          { name: "endTime", type: "uint256", internalType: "uint256" },
+          { name: "zoneHash", type: "bytes32", internalType: "bytes32" },
+          { name: "salt", type: "uint256", internalType: "uint256" },
+          { name: "conduitKey", type: "bytes32", internalType: "bytes32" },
+          { name: "totalOriginalConsiderationItems", type: "uint256", internalType: "uint256" }
+        ]
+      },
+      { name: "counter", type: "uint256", internalType: "uint256" },
+      { name: "signature", type: "bytes", internalType: "bytes" }
+    ]
+  }
+];
+
+// src/chainConfig.ts
+var DEFAULT_SEAPORT_ADDRESS = "0x0000000000000068F116a894984e2DB1123eB395";
+var DEFAULT_BAZAAR_ADDRESS = "0x00000000E3dA5fC031282A39759bDDA78ae7fAE5";
+var DEFAULT_COLLECTION_OFFERS_ADDRESS = "0x0000000D43423E0A12CecB307a74591999b32B32";
+var DEFAULT_FEE_COLLECTOR_ADDRESS = "0x32D16C15410248bef498D7aF50D10Db1a546b9E5";
+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 NET_SEAPORT_COLLECTION_OFFER_ZONE_ADDRESS = "0x000000B799ec6D7aCC1B578f62bFc324c25DFC5A";
+var BAZAAR_CHAIN_CONFIGS = {
+  // Base Mainnet
+  8453: {
+    bazaarAddress: "0x000000058f3ade587388daf827174d0e6fc97595",
+    collectionOffersAddress: "0x0000000f9c45efcff0f78d8b54aa6a40092d66dc",
+    erc20OffersAddress: "0x0000000e23a89aa06f317306aa1ae231d3503082",
+    seaportAddress: DEFAULT_SEAPORT_ADDRESS,
+    feeCollectorAddress: "0x66547ff4f7206e291F7BC157b54C026Fc6660961",
+    nftFeeBps: 0,
+    // 0% on Base
+    wrappedNativeCurrency: {
+      address: "0x4200000000000000000000000000000000000006",
+      name: "Wrapped Ether",
+      symbol: "WETH"
+    },
+    currencySymbol: "eth"
+  },
+  // Base Sepolia (Testnet)
+  84532: {
+    bazaarAddress: DEFAULT_BAZAAR_ADDRESS,
+    collectionOffersAddress: DEFAULT_COLLECTION_OFFERS_ADDRESS,
+    seaportAddress: DEFAULT_SEAPORT_ADDRESS,
+    feeCollectorAddress: DEFAULT_FEE_COLLECTOR_ADDRESS,
+    nftFeeBps: DEFAULT_NFT_FEE_BPS,
+    wrappedNativeCurrency: {
+      address: "0x4200000000000000000000000000000000000006",
+      name: "Wrapped Ether",
+      symbol: "WETH"
+    },
+    currencySymbol: "eth"
+  },
+  // Degen
+  666666666: {
+    bazaarAddress: DEFAULT_BAZAAR_ADDRESS,
+    collectionOffersAddress: DEFAULT_COLLECTION_OFFERS_ADDRESS,
+    seaportAddress: DEFAULT_SEAPORT_ADDRESS,
+    feeCollectorAddress: DEFAULT_FEE_COLLECTOR_ADDRESS,
+    nftFeeBps: DEFAULT_NFT_FEE_BPS,
+    wrappedNativeCurrency: {
+      address: "0xEb54dACB4C2ccb64F8074eceEa33b5eBb38E5387",
+      name: "Wrapped Degen",
+      symbol: "WDEGEN"
+    },
+    currencySymbol: "degen"
+  },
+  // Ham Chain
+  5112: {
+    bazaarAddress: DEFAULT_BAZAAR_ADDRESS,
+    collectionOffersAddress: DEFAULT_COLLECTION_OFFERS_ADDRESS,
+    seaportAddress: DEFAULT_SEAPORT_ADDRESS,
+    feeCollectorAddress: DEFAULT_FEE_COLLECTOR_ADDRESS,
+    nftFeeBps: DEFAULT_NFT_FEE_BPS,
+    wrappedNativeCurrency: {
+      address: "0x4200000000000000000000000000000000000006",
+      name: "Wrapped Ether",
+      symbol: "WETH"
+    },
+    highEthAddress: "0x4200000000000000000000000000000000000006",
+    currencySymbol: "eth"
+  },
+  // Ink Chain
+  57073: {
+    bazaarAddress: DEFAULT_BAZAAR_ADDRESS,
+    collectionOffersAddress: DEFAULT_COLLECTION_OFFERS_ADDRESS,
+    // Custom Seaport address for Ink (no create2 factory)
+    seaportAddress: "0xD00C96804e9fF35f10C7D2a92239C351Ff3F94e5",
+    feeCollectorAddress: DEFAULT_FEE_COLLECTOR_ADDRESS,
+    nftFeeBps: DEFAULT_NFT_FEE_BPS,
+    wrappedNativeCurrency: {
+      address: "0x4200000000000000000000000000000000000006",
+      name: "Wrapped ETH",
+      symbol: "WETH"
+    },
+    highEthAddress: "0x4200000000000000000000000000000000000006",
+    currencySymbol: "eth"
+  },
+  // Unichain
+  130: {
+    bazaarAddress: DEFAULT_BAZAAR_ADDRESS,
+    collectionOffersAddress: DEFAULT_COLLECTION_OFFERS_ADDRESS,
+    seaportAddress: DEFAULT_SEAPORT_ADDRESS,
+    feeCollectorAddress: DEFAULT_FEE_COLLECTOR_ADDRESS,
+    nftFeeBps: DEFAULT_NFT_FEE_BPS,
+    wrappedNativeCurrency: {
+      address: "0x4200000000000000000000000000000000000006",
+      name: "Wrapped Ether",
+      symbol: "WETH"
+    },
+    currencySymbol: "eth"
+  },
+  // HyperEVM (Hyperliquid)
+  999: {
+    bazaarAddress: "0x000000058f3ade587388daf827174d0e6fc97595",
+    collectionOffersAddress: "0x0000000f9c45efcff0f78d8b54aa6a40092d66dc",
+    erc20OffersAddress: "0x0000000e23a89aa06f317306aa1ae231d3503082",
+    seaportAddress: DEFAULT_SEAPORT_ADDRESS,
+    feeCollectorAddress: "0x66547ff4f7206e291F7BC157b54C026Fc6660961",
+    nftFeeBps: 0,
+    // 0% on HyperEVM
+    wrappedNativeCurrency: {
+      address: "0x5555555555555555555555555555555555555555",
+      name: "Wrapped Hype",
+      symbol: "WHYPE"
+    },
+    currencySymbol: "hype"
+  },
+  // Plasma
+  9745: {
+    bazaarAddress: DEFAULT_BAZAAR_ADDRESS,
+    collectionOffersAddress: DEFAULT_COLLECTION_OFFERS_ADDRESS,
+    seaportAddress: DEFAULT_SEAPORT_ADDRESS,
+    feeCollectorAddress: DEFAULT_FEE_COLLECTOR_ADDRESS,
+    nftFeeBps: DEFAULT_NFT_FEE_BPS,
+    wrappedNativeCurrency: {
+      address: "0x6100e367285b01f48d07953803a2d8dca5d19873",
+      name: "Wrapped XPL",
+      symbol: "WXPL"
+    },
+    currencySymbol: "xpl"
+  },
+  // Monad
+  143: {
+    bazaarAddress: DEFAULT_BAZAAR_ADDRESS,
+    collectionOffersAddress: DEFAULT_COLLECTION_OFFERS_ADDRESS,
+    seaportAddress: DEFAULT_SEAPORT_ADDRESS,
+    feeCollectorAddress: DEFAULT_FEE_COLLECTOR_ADDRESS,
+    nftFeeBps: DEFAULT_NFT_FEE_BPS,
+    wrappedNativeCurrency: {
+      address: "0x3bd359C1119dA7Da1D913D1C4D2B7c461115433A",
+      name: "Wrapped Monad",
+      symbol: "WMONAD"
+    },
+    currencySymbol: "monad"
+  }
+};
+function getBazaarChainConfig(chainId) {
+  return BAZAAR_CHAIN_CONFIGS[chainId];
+}
+function isBazaarSupportedOnChain(chainId) {
+  return chainId in BAZAAR_CHAIN_CONFIGS;
+}
+function getBazaarAddress(chainId) {
+  return BAZAAR_CHAIN_CONFIGS[chainId]?.bazaarAddress ?? DEFAULT_BAZAAR_ADDRESS;
+}
+function getCollectionOffersAddress(chainId) {
+  return BAZAAR_CHAIN_CONFIGS[chainId]?.collectionOffersAddress ?? DEFAULT_COLLECTION_OFFERS_ADDRESS;
+}
+function getSeaportAddress(chainId) {
+  return BAZAAR_CHAIN_CONFIGS[chainId]?.seaportAddress ?? DEFAULT_SEAPORT_ADDRESS;
+}
+function getWrappedNativeCurrency(chainId) {
+  return BAZAAR_CHAIN_CONFIGS[chainId]?.wrappedNativeCurrency;
+}
+function getCurrencySymbol(chainId) {
+  return BAZAAR_CHAIN_CONFIGS[chainId]?.currencySymbol ?? "eth";
+}
+function getHighEthAddress(chainId) {
+  return BAZAAR_CHAIN_CONFIGS[chainId]?.highEthAddress;
+}
+function getErc20OffersAddress(chainId) {
+  return BAZAAR_CHAIN_CONFIGS[chainId]?.erc20OffersAddress;
+}
+function decodeSeaportSubmission(messageData) {
+  const [decoded] = decodeAbiParameters(BAZAAR_SUBMISSION_ABI, messageData);
+  return {
+    parameters: {
+      offerer: decoded.parameters.offerer,
+      zone: decoded.parameters.zone,
+      offer: decoded.parameters.offer.map((item) => ({
+        itemType: item.itemType,
+        token: item.token,
+        identifierOrCriteria: BigInt(item.identifierOrCriteria),
+        startAmount: BigInt(item.startAmount),
+        endAmount: BigInt(item.endAmount)
+      })),
+      consideration: decoded.parameters.consideration.map((item) => ({
+        itemType: item.itemType,
+        token: item.token,
+        identifierOrCriteria: BigInt(item.identifierOrCriteria),
+        startAmount: BigInt(item.startAmount),
+        endAmount: BigInt(item.endAmount),
+        recipient: item.recipient
+      })),
+      orderType: decoded.parameters.orderType,
+      startTime: BigInt(decoded.parameters.startTime),
+      endTime: BigInt(decoded.parameters.endTime),
+      zoneHash: decoded.parameters.zoneHash,
+      salt: BigInt(decoded.parameters.salt),
+      conduitKey: decoded.parameters.conduitKey,
+      totalOriginalConsiderationItems: BigInt(decoded.parameters.totalOriginalConsiderationItems)
+    },
+    counter: BigInt(decoded.counter),
+    signature: decoded.signature
+  };
+}
+function getSeaportOrderFromMessageData(messageData) {
+  const submission = decodeSeaportSubmission(messageData);
+  return {
+    parameters: {
+      ...submission.parameters,
+      // Convert BigInts to strings for Seaport SDK compatibility
+      offer: submission.parameters.offer.map((item) => ({
+        ...item,
+        identifierOrCriteria: item.identifierOrCriteria.toString(),
+        startAmount: item.startAmount.toString(),
+        endAmount: item.endAmount.toString()
+      })),
+      consideration: submission.parameters.consideration.map((item) => ({
+        ...item,
+        identifierOrCriteria: item.identifierOrCriteria.toString(),
+        startAmount: item.startAmount.toString(),
+        endAmount: item.endAmount.toString()
+      })),
+      startTime: submission.parameters.startTime.toString(),
+      endTime: submission.parameters.endTime.toString(),
+      salt: submission.parameters.salt.toString(),
+      totalOriginalConsiderationItems: submission.parameters.totalOriginalConsiderationItems.toString(),
+      counter: submission.counter.toString()
+    },
+    signature: submission.signature,
+    counter: submission.counter
+  };
+}
+function createSeaportInstance(chainId, rpcUrl) {
+  const provider = new ethers.JsonRpcProvider(rpcUrl);
+  const signer = new ethers.Wallet(
+    // Random private key for read-only operations
+    "dc63e9af2088e2afd61499411cb6dd718d00a3d9e46e2cb5e33912c781bd77fe",
+    provider
+  );
+  const highEthAddress = getHighEthAddress(chainId);
+  const finalSigner = highEthAddress ? {
+    ...signer,
+    getAddress: () => highEthAddress,
+    address: highEthAddress
+  } : signer;
+  return new Seaport(finalSigner, {
+    overrides: { contractAddress: getSeaportAddress(chainId) }
+  });
+}
+function computeOrderHash(seaport, orderParameters, counter) {
+  return seaport.getOrderHash({
+    ...orderParameters,
+    counter: counter.toString()
+  });
+}
+function getOrderStatusFromInfo(orderParameters, statusInfo) {
+  if (statusInfo.isCancelled) {
+    return 0 /* CANCELLED */;
+  }
+  if (statusInfo.totalFilled === statusInfo.totalSize && statusInfo.totalFilled > BigInt(0)) {
+    return 3 /* FILLED */;
+  }
+  const now = BigInt(Math.floor(Date.now() / 1e3));
+  if (orderParameters.endTime < now) {
+    return 1 /* EXPIRED */;
+  }
+  return 2 /* OPEN */;
+}
+function getTotalConsiderationAmount(parameters) {
+  return parameters.consideration.reduce(
+    (acc, item) => acc + item.startAmount,
+    BigInt(0)
+  );
+}
+function formatPrice(priceWei) {
+  return parseFloat(formatEther(priceWei));
+}
+async function bulkFetchOrderStatuses(client, chainId, orderHashes) {
+  if (orderHashes.length === 0) {
+    return [];
+  }
+  const seaportAddress = getSeaportAddress(chainId);
+  const results = await 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)
+  }));
+}
+async function bulkFetchNftOwners(client, nftAddress, tokenIds) {
+  if (tokenIds.length === 0) {
+    return [];
+  }
+  try {
+    const owners = await 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(
+      (owner) => owner === "0x0000000000000000000000000000000000000000" ? null : owner
+    );
+  } catch {
+    return tokenIds.map(() => null);
+  }
+}
+async function bulkFetchErc20Balances(client, tokenAddress, addresses) {
+  if (addresses.length === 0) {
+    return [];
+  }
+  try {
+    const balances = await 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 {
+    return addresses.map(() => BigInt(0));
+  }
+}
+function isListingValid(orderStatus, expirationDate, sellerAddress, currentOwner) {
+  if (orderStatus !== 2 /* OPEN */) {
+    return false;
+  }
+  const now = Math.floor(Date.now() / 1e3);
+  if (expirationDate <= now) {
+    return false;
+  }
+  if (!currentOwner || currentOwner.toLowerCase() !== sellerAddress.toLowerCase()) {
+    return false;
+  }
+  return true;
+}
+function isCollectionOfferValid(orderStatus, expirationDate, priceWei, buyerBalance) {
+  if (orderStatus !== 2 /* OPEN */) {
+    return false;
+  }
+  const now = Math.floor(Date.now() / 1e3);
+  if (expirationDate <= now) {
+    return false;
+  }
+  if (buyerBalance < priceWei) {
+    return false;
+  }
+  return true;
+}
+function isErc20OfferValid(orderStatus, expirationDate, priceWei, buyerWethBalance) {
+  if (orderStatus !== 2 /* OPEN */) {
+    return false;
+  }
+  const now = Math.floor(Date.now() / 1e3);
+  if (expirationDate <= now) {
+    return false;
+  }
+  if (buyerWethBalance < priceWei) {
+    return false;
+  }
+  return true;
+}
+
+// src/utils/parsing.ts
+function parseListingFromMessage(message, chainId) {
+  try {
+    const submission = decodeSeaportSubmission(message.data);
+    const { parameters } = submission;
+    const offerItem = parameters.offer[0];
+    if (!offerItem) {
+      return null;
+    }
+    if (offerItem.itemType !== 2 /* ERC721 */ && offerItem.itemType !== 3 /* ERC1155 */) {
+      return null;
+    }
+    const priceWei = getTotalConsiderationAmount(parameters);
+    const tokenId = offerItem.identifierOrCriteria.toString();
+    return {
+      maker: parameters.offerer,
+      nftAddress: offerItem.token,
+      tokenId,
+      priceWei,
+      price: formatPrice(priceWei),
+      currency: getCurrencySymbol(chainId),
+      expirationDate: Number(parameters.endTime),
+      orderHash: "",
+      // Will be computed later
+      orderStatus: 2 /* OPEN */,
+      // Will be validated later
+      messageData: message.data,
+      orderComponents: {
+        ...parameters,
+        counter: submission.counter
+      }
+    };
+  } catch {
+    return null;
+  }
+}
+function parseCollectionOfferFromMessage(message, chainId) {
+  try {
+    const submission = decodeSeaportSubmission(message.data);
+    const { parameters } = submission;
+    if (parameters.zone.toLowerCase() !== NET_SEAPORT_COLLECTION_OFFER_ZONE_ADDRESS.toLowerCase()) {
+      return null;
+    }
+    const offerItem = parameters.offer[0];
+    if (!offerItem || offerItem.itemType !== 1 /* ERC20 */) {
+      return null;
+    }
+    const nftConsideration = parameters.consideration.find(
+      (item) => item.itemType === 4 /* ERC721_WITH_CRITERIA */ || item.itemType === 5 /* ERC1155_WITH_CRITERIA */
+    );
+    if (!nftConsideration) {
+      return null;
+    }
+    if (nftConsideration.startAmount !== BigInt(1)) {
+      return null;
+    }
+    const priceWei = offerItem.startAmount;
+    return {
+      maker: parameters.offerer,
+      nftAddress: nftConsideration.token,
+      priceWei,
+      price: formatPrice(priceWei),
+      currency: getCurrencySymbol(chainId),
+      expirationDate: Number(parameters.endTime),
+      orderHash: "",
+      // Will be computed later
+      orderStatus: 2 /* OPEN */,
+      // Will be validated later
+      messageData: message.data,
+      orderComponents: {
+        ...parameters,
+        counter: submission.counter
+      }
+    };
+  } catch {
+    return null;
+  }
+}
+function getBestListingPerToken(listings) {
+  const tokenMap = /* @__PURE__ */ new Map();
+  for (const listing of listings) {
+    const key = `${listing.nftAddress.toLowerCase()}-${listing.tokenId}`;
+    const existing = tokenMap.get(key);
+    if (!existing || listing.priceWei < existing.priceWei) {
+      tokenMap.set(key, listing);
+    }
+  }
+  return Array.from(tokenMap.values());
+}
+function sortListingsByPrice(listings) {
+  return [...listings].sort((a, b) => {
+    const diff = a.priceWei - b.priceWei;
+    if (diff < BigInt(0)) return -1;
+    if (diff > BigInt(0)) return 1;
+    return 0;
+  });
+}
+function sortOffersByPrice(offers) {
+  return [...offers].sort((a, b) => {
+    const diff = b.priceWei - a.priceWei;
+    if (diff < BigInt(0)) return -1;
+    if (diff > BigInt(0)) return 1;
+    return 0;
+  });
+}
+function parseErc20OfferFromMessage(message, chainId) {
+  try {
+    const submission = decodeSeaportSubmission(message.data);
+    const { parameters } = submission;
+    if (parameters.zone.toLowerCase() !== NET_SEAPORT_COLLECTION_OFFER_ZONE_ADDRESS.toLowerCase()) {
+      return null;
+    }
+    const offerItem = parameters.offer[0];
+    if (!offerItem || offerItem.itemType !== 1 /* ERC20 */) {
+      return null;
+    }
+    const erc20Consideration = parameters.consideration.find(
+      (item) => item.itemType === 1 /* ERC20 */
+    );
+    if (!erc20Consideration) {
+      return null;
+    }
+    const tokenAmount = erc20Consideration.startAmount;
+    if (tokenAmount === BigInt(0)) {
+      return null;
+    }
+    const priceWei = offerItem.startAmount;
+    const pricePerTokenWei = priceWei / tokenAmount;
+    return {
+      maker: parameters.offerer,
+      tokenAddress: erc20Consideration.token,
+      tokenAmount,
+      priceWei,
+      pricePerTokenWei,
+      price: formatPrice(priceWei),
+      pricePerToken: formatPrice(pricePerTokenWei),
+      currency: getCurrencySymbol(chainId),
+      expirationDate: Number(parameters.endTime),
+      orderHash: "0x",
+      // Will be computed later
+      orderStatus: 2 /* OPEN */,
+      // Will be validated later
+      messageData: message.data,
+      orderComponents: {
+        ...parameters,
+        counter: submission.counter
+      }
+    };
+  } catch {
+    return null;
+  }
+}
+function sortErc20OffersByPricePerToken(offers) {
+  return [...offers].sort((a, b) => {
+    const diff = b.pricePerTokenWei - a.pricePerTokenWei;
+    if (diff < BigInt(0)) return -1;
+    if (diff > BigInt(0)) return 1;
+    return 0;
+  });
+}
+
+// src/client/BazaarClient.ts
+var CHAIN_RPC_URLS = {
+  8453: ["https://base-mainnet.public.blastapi.io", "https://mainnet.base.org"],
+  84532: ["https://sepolia.base.org"],
+  666666666: ["https://rpc.degen.tips"],
+  5112: ["https://rpc.ham.fun"],
+  57073: ["https://rpc-qnd.inkonchain.com"],
+  130: ["https://mainnet.unichain.org"],
+  999: ["https://rpc.hyperliquid.xyz/evm"],
+  9745: ["https://rpc.plasma.to"],
+  143: ["https://rpc3.monad.xyz"]
+};
+var BazaarClient = class {
+  constructor(params) {
+    if (!isBazaarSupportedOnChain(params.chainId)) {
+      throw new Error(`Bazaar is not supported on chain ${params.chainId}`);
+    }
+    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}`);
+    }
+    const config = getBazaarChainConfig(params.chainId);
+    this.client = createPublicClient({
+      chain: 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: http(this.rpcUrl),
+      batch: { multicall: true }
+    });
+    this.netClient = new NetClient({
+      chainId: params.chainId,
+      overrides: params.rpcUrl ? { rpcUrls: [params.rpcUrl] } : void 0
+    });
+  }
+  /**
+   * Get valid NFT listings for a collection
+   *
+   * Returns listings that are:
+   * - OPEN status (not filled, cancelled, or expired)
+   * - Not expired
+   * - Seller still owns the NFT
+   *
+   * Results are deduplicated (one per token) and sorted by price (lowest first)
+   */
+  async getListings(options) {
+    const { nftAddress, excludeMaker, maxMessages = 200 } = options;
+    const bazaarAddress = getBazaarAddress(this.chainId);
+    const count = await this.netClient.getMessageCount({
+      filter: {
+        appAddress: bazaarAddress,
+        topic: nftAddress.toLowerCase()
+      }
+    });
+    if (count === 0) {
+      return [];
+    }
+    const startIndex = Math.max(0, count - maxMessages);
+    const messages = await this.netClient.getMessages({
+      filter: {
+        appAddress: bazaarAddress,
+        topic: nftAddress.toLowerCase()
+      },
+      startIndex,
+      endIndex: count
+    });
+    let listings = [];
+    for (const message of messages) {
+      const listing = parseListingFromMessage(message, this.chainId);
+      if (!listing) continue;
+      if (excludeMaker && listing.maker.toLowerCase() === excludeMaker.toLowerCase()) {
+        continue;
+      }
+      listings.push(listing);
+    }
+    if (listings.length === 0) {
+      return [];
+    }
+    const seaport = createSeaportInstance(this.chainId, this.rpcUrl);
+    for (const listing of listings) {
+      const order = getSeaportOrderFromMessageData(listing.messageData);
+      listing.orderHash = computeOrderHash(seaport, order.parameters, order.counter);
+    }
+    const orderHashes = listings.map((l) => l.orderHash);
+    const statusInfos = await bulkFetchOrderStatuses(this.client, this.chainId, orderHashes);
+    listings.forEach((listing, index) => {
+      const statusInfo = statusInfos[index];
+      listing.orderStatus = getOrderStatusFromInfo(listing.orderComponents, statusInfo);
+    });
+    listings = listings.filter(
+      (l) => l.orderStatus === 2 /* OPEN */ && l.expirationDate > Math.floor(Date.now() / 1e3)
+    );
+    if (listings.length === 0) {
+      return [];
+    }
+    const tokenIds = listings.map((l) => l.tokenId);
+    const owners = await bulkFetchNftOwners(this.client, nftAddress, tokenIds);
+    listings = listings.filter((listing, index) => {
+      const owner = owners[index];
+      return isListingValid(
+        listing.orderStatus,
+        listing.expirationDate,
+        listing.maker,
+        owner
+      );
+    });
+    return sortListingsByPrice(getBestListingPerToken(listings));
+  }
+  /**
+   * Get valid collection offers for a collection
+   *
+   * Returns offers that are:
+   * - OPEN status (not filled, cancelled, or expired)
+   * - Not expired
+   * - Buyer has sufficient WETH balance
+   *
+   * Results are sorted by price (highest first)
+   */
+  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,
+        topic: nftAddress.toLowerCase()
+      }
+    });
+    if (count === 0) {
+      return [];
+    }
+    const startIndex = Math.max(0, count - maxMessages);
+    const messages = await this.netClient.getMessages({
+      filter: {
+        appAddress: collectionOffersAddress,
+        topic: nftAddress.toLowerCase()
+      },
+      startIndex,
+      endIndex: count
+    });
+    let offers = [];
+    for (const message of messages) {
+      const offer = parseCollectionOfferFromMessage(message, this.chainId);
+      if (!offer) continue;
+      const order = getSeaportOrderFromMessageData(offer.messageData);
+      const offerToken = order.parameters.offer?.[0]?.token?.toLowerCase();
+      if (offerToken !== weth.address.toLowerCase()) {
+        continue;
+      }
+      if (excludeMaker && offer.maker.toLowerCase() === excludeMaker.toLowerCase()) {
+        continue;
+      }
+      offers.push(offer);
+    }
+    if (offers.length === 0) {
+      return [];
+    }
+    const seaport = createSeaportInstance(this.chainId, this.rpcUrl);
+    for (const offer of offers) {
+      const order = getSeaportOrderFromMessageData(offer.messageData);
+      offer.orderHash = computeOrderHash(seaport, order.parameters, order.counter);
+    }
+    const orderHashes = offers.map((o) => o.orderHash);
+    const statusInfos = await bulkFetchOrderStatuses(this.client, this.chainId, orderHashes);
+    offers.forEach((offer, index) => {
+      const statusInfo = statusInfos[index];
+      offer.orderStatus = getOrderStatusFromInfo(offer.orderComponents, statusInfo);
+    });
+    offers = offers.filter(
+      (o) => o.orderStatus === 2 /* OPEN */ && o.expirationDate > Math.floor(Date.now() / 1e3)
+    );
+    if (offers.length === 0) {
+      return [];
+    }
+    const uniqueMakers = [...new Set(offers.map((o) => o.maker))];
+    const balances = await bulkFetchErc20Balances(this.client, weth.address, uniqueMakers);
+    const balanceMap = /* @__PURE__ */ new Map();
+    uniqueMakers.forEach((maker, index) => {
+      balanceMap.set(maker.toLowerCase(), balances[index]);
+    });
+    offers = offers.filter((offer) => {
+      const balance = balanceMap.get(offer.maker.toLowerCase()) || BigInt(0);
+      return isCollectionOfferValid(
+        offer.orderStatus,
+        offer.expirationDate,
+        offer.priceWei,
+        balance
+      );
+    });
+    return sortOffersByPrice(offers);
+  }
+  /**
+   * Get valid ERC20 offers for a token
+   *
+   * ERC20 offers are only available on Base (8453) and HyperEVM (999).
+   *
+   * Returns offers that are:
+   * - OPEN status (not filled, cancelled, or expired)
+   * - Not expired
+   * - Buyer has sufficient WETH balance
+   *
+   * Results are sorted by price per token (highest first)
+   */
+  async getErc20Offers(options) {
+    const { tokenAddress, excludeMaker, maxMessages = 200 } = options;
+    const erc20OffersAddress = getErc20OffersAddress(this.chainId);
+    const weth = getWrappedNativeCurrency(this.chainId);
+    if (!erc20OffersAddress || !weth) {
+      return [];
+    }
+    const count = await this.netClient.getMessageCount({
+      filter: {
+        appAddress: erc20OffersAddress,
+        topic: tokenAddress.toLowerCase()
+      }
+    });
+    if (count === 0) {
+      return [];
+    }
+    const startIndex = Math.max(0, count - maxMessages);
+    const messages = await this.netClient.getMessages({
+      filter: {
+        appAddress: erc20OffersAddress,
+        topic: tokenAddress.toLowerCase()
+      },
+      startIndex,
+      endIndex: count
+    });
+    let offers = [];
+    for (const message of messages) {
+      const offer = parseErc20OfferFromMessage(message, this.chainId);
+      if (!offer) continue;
+      const order = getSeaportOrderFromMessageData(offer.messageData);
+      const offerToken = order.parameters.offer?.[0]?.token?.toLowerCase();
+      if (offerToken !== weth.address.toLowerCase()) {
+        continue;
+      }
+      if (offer.tokenAddress.toLowerCase() !== tokenAddress.toLowerCase()) {
+        continue;
+      }
+      if (excludeMaker && offer.maker.toLowerCase() === excludeMaker.toLowerCase()) {
+        continue;
+      }
+      offers.push(offer);
+    }
+    if (offers.length === 0) {
+      return [];
+    }
+    const seaport = createSeaportInstance(this.chainId, this.rpcUrl);
+    for (const offer of offers) {
+      const order = getSeaportOrderFromMessageData(offer.messageData);
+      offer.orderHash = computeOrderHash(seaport, order.parameters, order.counter);
+    }
+    const orderHashes = offers.map((o) => o.orderHash);
+    const statusInfos = await bulkFetchOrderStatuses(this.client, this.chainId, orderHashes);
+    offers.forEach((offer, index) => {
+      const statusInfo = statusInfos[index];
+      offer.orderStatus = getOrderStatusFromInfo(offer.orderComponents, statusInfo);
+    });
+    offers = offers.filter(
+      (o) => o.orderStatus === 2 /* OPEN */ && o.expirationDate > Math.floor(Date.now() / 1e3)
+    );
+    if (offers.length === 0) {
+      return [];
+    }
+    const uniqueMakers = [...new Set(offers.map((o) => o.maker))];
+    const balances = await bulkFetchErc20Balances(this.client, weth.address, uniqueMakers);
+    const balanceMap = /* @__PURE__ */ new Map();
+    uniqueMakers.forEach((maker, index) => {
+      balanceMap.set(maker.toLowerCase(), balances[index]);
+    });
+    offers = offers.filter((offer) => {
+      const balance = balanceMap.get(offer.maker.toLowerCase()) || BigInt(0);
+      return isErc20OfferValid(
+        offer.orderStatus,
+        offer.expirationDate,
+        offer.priceWei,
+        balance
+      );
+    });
+    return sortErc20OffersByPricePerToken(offers);
+  }
+  /**
+   * Get the chain ID this client is configured for
+   */
+  getChainId() {
+    return this.chainId;
+  }
+  /**
+   * Get the bazaar contract address for this chain
+   */
+  getBazaarAddress() {
+    return getBazaarAddress(this.chainId);
+  }
+  /**
+   * Get the collection offers contract address for this chain
+   */
+  getCollectionOffersAddress() {
+    return getCollectionOffersAddress(this.chainId);
+  }
+  /**
+   * Get the ERC20 offers contract address for this chain
+   * Only available on Base (8453) and HyperEVM (999)
+   */
+  getErc20OffersAddress() {
+    return getErc20OffersAddress(this.chainId);
+  }
+  /**
+   * Get the Seaport contract address for this chain
+   */
+  getSeaportAddress() {
+    return getSeaportAddress(this.chainId);
+  }
+  /**
+   * Prepare a transaction to cancel a listing
+   *
+   * The listing must have been created by the caller.
+   * Use the orderComponents from the Listing object returned by getListings().
+   */
+  prepareCancelListing(listing) {
+    if (!listing.orderComponents) {
+      throw new Error("Listing does not have order components");
+    }
+    return this.prepareCancelOrder(listing.orderComponents);
+  }
+  /**
+   * Prepare a transaction to cancel a collection offer
+   *
+   * The offer must have been created by the caller.
+   * Use the orderComponents from the CollectionOffer object returned by getCollectionOffers().
+   */
+  prepareCancelCollectionOffer(offer) {
+    if (!offer.orderComponents) {
+      throw new Error("Offer does not have order components");
+    }
+    return this.prepareCancelOrder(offer.orderComponents);
+  }
+  /**
+   * Prepare a transaction to cancel a Seaport order
+   *
+   * This is a low-level method. Prefer prepareCancelListing or prepareCancelCollectionOffer.
+   */
+  prepareCancelOrder(orderComponents) {
+    const seaportAddress = getSeaportAddress(this.chainId);
+    const orderForCancel = {
+      offerer: orderComponents.offerer,
+      zone: orderComponents.zone,
+      offer: orderComponents.offer.map((item) => ({
+        itemType: item.itemType,
+        token: item.token,
+        identifierOrCriteria: item.identifierOrCriteria,
+        startAmount: item.startAmount,
+        endAmount: item.endAmount
+      })),
+      consideration: orderComponents.consideration.map((item) => ({
+        itemType: item.itemType,
+        token: item.token,
+        identifierOrCriteria: item.identifierOrCriteria,
+        startAmount: item.startAmount,
+        endAmount: item.endAmount,
+        recipient: item.recipient
+      })),
+      orderType: orderComponents.orderType,
+      startTime: orderComponents.startTime,
+      endTime: orderComponents.endTime,
+      zoneHash: orderComponents.zoneHash,
+      salt: orderComponents.salt,
+      conduitKey: orderComponents.conduitKey,
+      counter: orderComponents.counter
+    };
+    return {
+      to: seaportAddress,
+      functionName: "cancel",
+      args: [[orderForCancel]],
+      abi: SEAPORT_CANCEL_ABI
+    };
+  }
+};
+
+// src/hooks/useBazaarListings.ts
+function useBazaarListings({
+  chainId,
+  nftAddress,
+  excludeMaker,
+  maxMessages = 200,
+  enabled = true
+}) {
+  const [listings, setListings] = useState([]);
+  const [isProcessing, setIsProcessing] = useState(false);
+  const [processingError, setProcessingError] = useState();
+  const [refetchTrigger, setRefetchTrigger] = useState(0);
+  const isSupported = useMemo(
+    () => isBazaarSupportedOnChain(chainId),
+    [chainId]
+  );
+  const bazaarAddress = useMemo(
+    () => isSupported ? getBazaarAddress(chainId) : void 0,
+    [chainId, isSupported]
+  );
+  const filter = useMemo(
+    () => ({
+      appAddress: bazaarAddress,
+      topic: nftAddress.toLowerCase()
+    }),
+    [bazaarAddress, nftAddress]
+  );
+  const { count: totalCount, isLoading: isLoadingCount } = useNetMessageCount({
+    chainId,
+    filter,
+    enabled: enabled && isSupported
+  });
+  const startIndex = useMemo(
+    () => Math.max(0, totalCount - maxMessages),
+    [totalCount, maxMessages]
+  );
+  const {
+    messages,
+    isLoading: isLoadingMessages,
+    error: messagesError,
+    refetch: refetchMessages
+  } = useNetMessages({
+    chainId,
+    filter,
+    startIndex,
+    endIndex: totalCount,
+    enabled: enabled && isSupported && totalCount > 0
+  });
+  useEffect(() => {
+    if (!isSupported || !enabled) {
+      setListings([]);
+      return;
+    }
+    if (!messages || messages.length === 0) {
+      setListings([]);
+      return;
+    }
+    let cancelled = false;
+    async function processListings() {
+      setIsProcessing(true);
+      setProcessingError(void 0);
+      try {
+        const client = new BazaarClient({ chainId });
+        const validListings = await client.getListings({
+          nftAddress,
+          excludeMaker,
+          maxMessages
+        });
+        if (!cancelled) {
+          setListings(validListings);
+        }
+      } catch (err) {
+        if (!cancelled) {
+          setProcessingError(err instanceof Error ? err : new Error(String(err)));
+          setListings([]);
+        }
+      } finally {
+        if (!cancelled) {
+          setIsProcessing(false);
+        }
+      }
+    }
+    processListings();
+    return () => {
+      cancelled = true;
+    };
+  }, [chainId, nftAddress, excludeMaker, maxMessages, messages, isSupported, enabled, refetchTrigger]);
+  const refetch = () => {
+    refetchMessages();
+    setRefetchTrigger((t) => t + 1);
+  };
+  return {
+    listings,
+    isLoading: isLoadingCount || isLoadingMessages || isProcessing,
+    error: messagesError || processingError,
+    refetch
+  };
+}
+function useBazaarCollectionOffers({
+  chainId,
+  nftAddress,
+  excludeMaker,
+  maxMessages = 100,
+  enabled = true
+}) {
+  const [offers, setOffers] = useState([]);
+  const [isProcessing, setIsProcessing] = useState(false);
+  const [processingError, setProcessingError] = useState();
+  const [refetchTrigger, setRefetchTrigger] = useState(0);
+  const isSupported = useMemo(
+    () => isBazaarSupportedOnChain(chainId),
+    [chainId]
+  );
+  const collectionOffersAddress = useMemo(
+    () => isSupported ? getCollectionOffersAddress(chainId) : void 0,
+    [chainId, isSupported]
+  );
+  const filter = useMemo(
+    () => ({
+      appAddress: collectionOffersAddress,
+      topic: nftAddress.toLowerCase()
+    }),
+    [collectionOffersAddress, nftAddress]
+  );
+  const { count: totalCount, isLoading: isLoadingCount } = useNetMessageCount({
+    chainId,
+    filter,
+    enabled: enabled && isSupported
+  });
+  const startIndex = useMemo(
+    () => Math.max(0, totalCount - maxMessages),
+    [totalCount, maxMessages]
+  );
+  const {
+    messages,
+    isLoading: isLoadingMessages,
+    error: messagesError,
+    refetch: refetchMessages
+  } = useNetMessages({
+    chainId,
+    filter,
+    startIndex,
+    endIndex: totalCount,
+    enabled: enabled && isSupported && totalCount > 0
+  });
+  useEffect(() => {
+    if (!isSupported || !enabled) {
+      setOffers([]);
+      return;
+    }
+    if (!messages || messages.length === 0) {
+      setOffers([]);
+      return;
+    }
+    let cancelled = false;
+    async function processOffers() {
+      setIsProcessing(true);
+      setProcessingError(void 0);
+      try {
+        const client = new BazaarClient({ chainId });
+        const validOffers = await client.getCollectionOffers({
+          nftAddress,
+          excludeMaker,
+          maxMessages
+        });
+        if (!cancelled) {
+          setOffers(validOffers);
+        }
+      } catch (err) {
+        if (!cancelled) {
+          setProcessingError(err instanceof Error ? err : new Error(String(err)));
+          setOffers([]);
+        }
+      } finally {
+        if (!cancelled) {
+          setIsProcessing(false);
+        }
+      }
+    }
+    processOffers();
+    return () => {
+      cancelled = true;
+    };
+  }, [chainId, nftAddress, excludeMaker, maxMessages, messages, isSupported, enabled, refetchTrigger]);
+  const refetch = () => {
+    refetchMessages();
+    setRefetchTrigger((t) => t + 1);
+  };
+  return {
+    offers,
+    isLoading: isLoadingCount || isLoadingMessages || isProcessing,
+    error: messagesError || processingError,
+    refetch
+  };
+}
+function useBazaarErc20Offers({
+  chainId,
+  tokenAddress,
+  excludeMaker,
+  maxMessages = 200,
+  enabled = true
+}) {
+  const [offers, setOffers] = useState([]);
+  const [isProcessing, setIsProcessing] = useState(false);
+  const [processingError, setProcessingError] = useState();
+  const [refetchTrigger, setRefetchTrigger] = useState(0);
+  const isSupported = useMemo(
+    () => isBazaarSupportedOnChain(chainId),
+    [chainId]
+  );
+  const erc20OffersAddress = useMemo(
+    () => isSupported ? getErc20OffersAddress(chainId) : void 0,
+    [chainId, isSupported]
+  );
+  const hasErc20Offers = Boolean(erc20OffersAddress);
+  const filter = useMemo(
+    () => ({
+      appAddress: erc20OffersAddress,
+      topic: tokenAddress.toLowerCase()
+    }),
+    [erc20OffersAddress, tokenAddress]
+  );
+  const { count: totalCount, isLoading: isLoadingCount } = useNetMessageCount({
+    chainId,
+    filter,
+    enabled: enabled && hasErc20Offers
+  });
+  const startIndex = useMemo(
+    () => Math.max(0, totalCount - maxMessages),
+    [totalCount, maxMessages]
+  );
+  const {
+    messages,
+    isLoading: isLoadingMessages,
+    error: messagesError,
+    refetch: refetchMessages
+  } = useNetMessages({
+    chainId,
+    filter,
+    startIndex,
+    endIndex: totalCount,
+    enabled: enabled && hasErc20Offers && totalCount > 0
+  });
+  useEffect(() => {
+    if (!hasErc20Offers || !enabled) {
+      setOffers([]);
+      return;
+    }
+    if (!messages || messages.length === 0) {
+      setOffers([]);
+      return;
+    }
+    let cancelled = false;
+    async function processOffers() {
+      setIsProcessing(true);
+      setProcessingError(void 0);
+      try {
+        const client = new BazaarClient({ chainId });
+        const validOffers = await client.getErc20Offers({
+          tokenAddress,
+          excludeMaker,
+          maxMessages
+        });
+        if (!cancelled) {
+          setOffers(validOffers);
+        }
+      } catch (err) {
+        if (!cancelled) {
+          setProcessingError(err instanceof Error ? err : new Error(String(err)));
+          setOffers([]);
+        }
+      } finally {
+        if (!cancelled) {
+          setIsProcessing(false);
+        }
+      }
+    }
+    processOffers();
+    return () => {
+      cancelled = true;
+    };
+  }, [chainId, tokenAddress, excludeMaker, maxMessages, messages, hasErc20Offers, enabled, refetchTrigger]);
+  const refetch = () => {
+    refetchMessages();
+    setRefetchTrigger((t) => t + 1);
+  };
+  return {
+    offers,
+    isLoading: isLoadingCount || isLoadingMessages || isProcessing,
+    error: messagesError || processingError,
+    refetch
+  };
+}
+
+export { useBazaarCollectionOffers, useBazaarErc20Offers, useBazaarListings };
+//# sourceMappingURL=react.mjs.map
+//# sourceMappingURL=react.mjs.map