@net-protocol/bazaar 0.1.6 → 0.1.8

package/dist/index.js

@@ -1,10 +1,10 @@
 'use strict';
 
 var viem = require('viem');
+var actions = require('viem/actions');
 var core = require('@net-protocol/core');
 var seaportJs = require('@opensea/seaport-js');
 var ethers = require('ethers');
-var actions = require('viem/actions');
 var storage = require('@net-protocol/storage');
 
 // src/client/BazaarClient.ts
@@ -187,6 +187,66 @@ var BAZAAR_COLLECTION_OFFERS_ABI = [
   { type: "error", name: "InvalidFee", inputs: [] },
   { type: "error", name: "OfferItemsMustContainOneItem", inputs: [] }
 ];
+var BAZAAR_ERC20_OFFERS_ABI = [
+  {
+    type: "function",
+    name: "submit",
+    inputs: [
+      {
+        name: "submission",
+        type: "tuple",
+        internalType: "struct BazaarV2CollectionOffers.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" }
+        ]
+      }
+    ],
+    outputs: [],
+    stateMutability: "nonpayable"
+  }
+];
 
 // src/abis/helpers.ts
 var BULK_SEAPORT_ORDER_STATUS_FETCHER_ABI = [
@@ -297,6 +357,161 @@ var SEAPORT_CANCEL_ABI = [
     type: "function"
   }
 ];
+var ORDER_PARAMETERS_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: "totalOriginalConsiderationItems", type: "uint256" }
+];
+var SEAPORT_FULFILL_ORDER_ABI = [
+  {
+    inputs: [
+      {
+        components: [
+          {
+            components: ORDER_PARAMETERS_COMPONENTS,
+            internalType: "struct OrderParameters",
+            name: "parameters",
+            type: "tuple"
+          },
+          { internalType: "bytes", name: "signature", type: "bytes" }
+        ],
+        internalType: "struct Order",
+        name: "",
+        type: "tuple"
+      },
+      { internalType: "bytes32", name: "fulfillerConduitKey", type: "bytes32" }
+    ],
+    name: "fulfillOrder",
+    outputs: [{ internalType: "bool", name: "fulfilled", type: "bool" }],
+    stateMutability: "payable",
+    type: "function"
+  }
+];
+var SEAPORT_FULFILL_ADVANCED_ORDER_ABI = [
+  {
+    inputs: [
+      {
+        components: [
+          {
+            components: ORDER_PARAMETERS_COMPONENTS,
+            internalType: "struct OrderParameters",
+            name: "parameters",
+            type: "tuple"
+          },
+          { internalType: "uint120", name: "numerator", type: "uint120" },
+          { internalType: "uint120", name: "denominator", type: "uint120" },
+          { internalType: "bytes", name: "signature", type: "bytes" },
+          { internalType: "bytes", name: "extraData", type: "bytes" }
+        ],
+        internalType: "struct AdvancedOrder",
+        name: "",
+        type: "tuple"
+      },
+      {
+        components: [
+          { internalType: "uint256", name: "orderIndex", type: "uint256" },
+          { internalType: "enum Side", name: "side", type: "uint8" },
+          { internalType: "uint256", name: "index", type: "uint256" },
+          { internalType: "uint256", name: "identifier", type: "uint256" },
+          { internalType: "bytes32[]", name: "criteriaProof", type: "bytes32[]" }
+        ],
+        internalType: "struct CriteriaResolver[]",
+        name: "",
+        type: "tuple[]"
+      },
+      { internalType: "bytes32", name: "fulfillerConduitKey", type: "bytes32" },
+      { internalType: "address", name: "recipient", type: "address" }
+    ],
+    name: "fulfillAdvancedOrder",
+    outputs: [{ internalType: "bool", name: "fulfilled", type: "bool" }],
+    stateMutability: "payable",
+    type: "function"
+  }
+];
+var SEAPORT_GET_COUNTER_ABI = [
+  {
+    inputs: [{ internalType: "address", name: "offerer", type: "address" }],
+    name: "getCounter",
+    outputs: [{ internalType: "uint256", name: "counter", type: "uint256" }],
+    stateMutability: "view",
+    type: "function"
+  }
+];
+var ERC721_APPROVAL_ABI = [
+  {
+    inputs: [
+      { internalType: "address", name: "owner", type: "address" },
+      { internalType: "address", name: "operator", type: "address" }
+    ],
+    name: "isApprovedForAll",
+    outputs: [{ internalType: "bool", name: "", type: "bool" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      { internalType: "address", name: "operator", type: "address" },
+      { internalType: "bool", name: "approved", type: "bool" }
+    ],
+    name: "setApprovalForAll",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  }
+];
+var ERC20_APPROVAL_ABI = [
+  {
+    inputs: [
+      { internalType: "address", name: "owner", type: "address" },
+      { internalType: "address", name: "spender", type: "address" }
+    ],
+    name: "allowance",
+    outputs: [{ internalType: "uint256", name: "", type: "uint256" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      { internalType: "address", name: "spender", type: "address" },
+      { internalType: "uint256", name: "amount", type: "uint256" }
+    ],
+    name: "approve",
+    outputs: [{ internalType: "bool", name: "", type: "bool" }],
+    stateMutability: "nonpayable",
+    type: "function"
+  }
+];
 
 // src/abis/index.ts
 var BAZAAR_SUBMISSION_ABI = [
@@ -1092,6 +1307,528 @@ function parseSaleFromStoredData(storedData, chainId) {
 function sortSalesByTimestamp(sales) {
   return [...sales].sort((a, b) => b.timestamp - a.timestamp);
 }
+var MAX_UINT256 = BigInt("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
+async function checkErc721Approval(client, nftAddress, owner, spender) {
+  const isApproved = await actions.readContract(client, {
+    address: nftAddress,
+    abi: ERC721_APPROVAL_ABI,
+    functionName: "isApprovedForAll",
+    args: [owner, spender]
+  });
+  if (isApproved) {
+    return null;
+  }
+  return {
+    to: nftAddress,
+    functionName: "setApprovalForAll",
+    args: [spender, true],
+    abi: ERC721_APPROVAL_ABI
+  };
+}
+async function checkErc20Approval(client, tokenAddress, owner, spender, amount) {
+  const allowance = await actions.readContract(client, {
+    address: tokenAddress,
+    abi: ERC20_APPROVAL_ABI,
+    functionName: "allowance",
+    args: [owner, spender]
+  });
+  if (allowance >= amount) {
+    return null;
+  }
+  return {
+    to: tokenAddress,
+    functionName: "approve",
+    args: [spender, MAX_UINT256],
+    abi: ERC20_APPROVAL_ABI
+  };
+}
+
+// src/utils/fulfillment.ts
+var ZERO_BYTES32 = "0x0000000000000000000000000000000000000000000000000000000000000000";
+function formatOrderParameters(params) {
+  return {
+    offerer: params.offerer,
+    zone: params.zone,
+    offer: params.offer.map((item) => ({
+      itemType: item.itemType,
+      token: item.token,
+      identifierOrCriteria: item.identifierOrCriteria,
+      startAmount: item.startAmount,
+      endAmount: item.endAmount
+    })),
+    consideration: params.consideration.map((item) => ({
+      itemType: item.itemType,
+      token: item.token,
+      identifierOrCriteria: item.identifierOrCriteria,
+      startAmount: item.startAmount,
+      endAmount: item.endAmount,
+      recipient: item.recipient
+    })),
+    orderType: params.orderType,
+    startTime: params.startTime,
+    endTime: params.endTime,
+    zoneHash: params.zoneHash,
+    salt: params.salt,
+    conduitKey: params.conduitKey,
+    totalOriginalConsiderationItems: params.totalOriginalConsiderationItems
+  };
+}
+function getNativeConsiderationValue(params) {
+  return params.consideration.reduce((acc, item) => {
+    if (item.itemType === 0 /* NATIVE */) {
+      return acc + item.startAmount;
+    }
+    return acc;
+  }, BigInt(0));
+}
+function buildFulfillListingTx(submission, recipient, seaportAddress) {
+  const advancedOrder = {
+    parameters: formatOrderParameters(submission.parameters),
+    numerator: BigInt(1),
+    denominator: BigInt(1),
+    signature: submission.signature,
+    extraData: "0x"
+  };
+  return {
+    to: seaportAddress,
+    functionName: "fulfillAdvancedOrder",
+    args: [advancedOrder, [], ZERO_BYTES32, recipient],
+    abi: SEAPORT_FULFILL_ADVANCED_ORDER_ABI,
+    value: getNativeConsiderationValue(submission.parameters)
+  };
+}
+function buildFulfillCollectionOfferTx(submission, tokenId, recipient, seaportAddress) {
+  const advancedOrder = {
+    parameters: formatOrderParameters(submission.parameters),
+    numerator: BigInt(1),
+    denominator: BigInt(1),
+    signature: submission.signature,
+    extraData: "0x"
+  };
+  const criteriaResolvers = [
+    {
+      orderIndex: BigInt(0),
+      side: 1,
+      // Consideration side
+      index: BigInt(0),
+      // First consideration item (the NFT)
+      identifier: tokenId,
+      criteriaProof: []
+    }
+  ];
+  return {
+    to: seaportAddress,
+    functionName: "fulfillAdvancedOrder",
+    args: [advancedOrder, criteriaResolvers, ZERO_BYTES32, recipient],
+    abi: SEAPORT_FULFILL_ADVANCED_ORDER_ABI,
+    value: BigInt(0)
+  };
+}
+function buildFulfillErc20OfferTx(submission, seaportAddress) {
+  const order = {
+    parameters: formatOrderParameters(submission.parameters),
+    signature: submission.signature
+  };
+  return {
+    to: seaportAddress,
+    functionName: "fulfillOrder",
+    args: [order, ZERO_BYTES32],
+    abi: SEAPORT_FULFILL_ORDER_ABI,
+    value: BigInt(0)
+  };
+}
+function buildFulfillErc20ListingTx(submission, recipient, seaportAddress) {
+  const advancedOrder = {
+    parameters: formatOrderParameters(submission.parameters),
+    numerator: BigInt(1),
+    denominator: BigInt(1),
+    signature: submission.signature,
+    extraData: "0x"
+  };
+  return {
+    to: seaportAddress,
+    functionName: "fulfillAdvancedOrder",
+    args: [advancedOrder, [], ZERO_BYTES32, recipient],
+    abi: SEAPORT_FULFILL_ADVANCED_ORDER_ABI,
+    value: getNativeConsiderationValue(submission.parameters)
+  };
+}
+var SEAPORT_EIP712_DOMAIN_NAME = "Seaport";
+var SEAPORT_EIP712_DOMAIN_VERSION = "1.6";
+var ZERO_BYTES322 = "0x0000000000000000000000000000000000000000000000000000000000000000";
+var ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";
+var SEAPORT_ORDER_EIP712_TYPES = {
+  OrderComponents: [
+    { name: "offerer", type: "address" },
+    { name: "zone", type: "address" },
+    { name: "offer", type: "OfferItem[]" },
+    { name: "consideration", type: "ConsiderationItem[]" },
+    { name: "orderType", type: "uint8" },
+    { name: "startTime", type: "uint256" },
+    { name: "endTime", type: "uint256" },
+    { name: "zoneHash", type: "bytes32" },
+    { name: "salt", type: "uint256" },
+    { name: "conduitKey", type: "bytes32" },
+    { name: "counter", type: "uint256" }
+  ],
+  OfferItem: [
+    { name: "itemType", type: "uint8" },
+    { name: "token", type: "address" },
+    { name: "identifierOrCriteria", type: "uint256" },
+    { name: "startAmount", type: "uint256" },
+    { name: "endAmount", type: "uint256" }
+  ],
+  ConsiderationItem: [
+    { name: "itemType", type: "uint8" },
+    { name: "token", type: "address" },
+    { name: "identifierOrCriteria", type: "uint256" },
+    { name: "startAmount", type: "uint256" },
+    { name: "endAmount", type: "uint256" },
+    { name: "recipient", type: "address" }
+  ]
+};
+function calculateFee(price, feeBps, useCeilingDivision) {
+  if (feeBps === 0) return BigInt(0);
+  const fee = price * BigInt(feeBps);
+  if (useCeilingDivision) {
+    return (fee + BigInt(9999)) / BigInt(1e4);
+  }
+  return fee / BigInt(1e4);
+}
+function generateSalt() {
+  const bytes = new Uint8Array(32);
+  if (typeof globalThis.crypto !== "undefined" && globalThis.crypto.getRandomValues) {
+    globalThis.crypto.getRandomValues(bytes);
+  } else {
+    for (let i = 0; i < 32; i++) {
+      bytes[i] = Math.floor(Math.random() * 256);
+    }
+  }
+  let hex = "0x";
+  for (const b of bytes) {
+    hex += b.toString(16).padStart(2, "0");
+  }
+  return BigInt(hex);
+}
+function getDefaultExpiration() {
+  return Math.floor(Date.now() / 1e3) + 86400;
+}
+function buildListingOrderComponents(params, chainId, counter) {
+  const feeBps = getNftFeeBps(chainId);
+  const feeAmount = calculateFee(params.priceWei, feeBps, false);
+  const sellerAmount = params.priceWei - feeAmount;
+  const endTime = BigInt(params.expirationDate ?? getDefaultExpiration());
+  const feeCollector = getFeeCollectorAddress(chainId);
+  const consideration = [
+    {
+      itemType: 0 /* NATIVE */,
+      token: ZERO_ADDRESS,
+      identifierOrCriteria: BigInt(0),
+      startAmount: sellerAmount,
+      endAmount: sellerAmount,
+      recipient: params.offerer
+    }
+  ];
+  if (feeAmount > BigInt(0)) {
+    consideration.push({
+      itemType: 0 /* NATIVE */,
+      token: ZERO_ADDRESS,
+      identifierOrCriteria: BigInt(0),
+      startAmount: feeAmount,
+      endAmount: feeAmount,
+      recipient: feeCollector
+    });
+  }
+  let zone;
+  let zoneHash;
+  if (params.targetFulfiller) {
+    zone = NET_SEAPORT_PRIVATE_ORDER_ZONE_ADDRESS;
+    zoneHash = viem.keccak256(viem.toBytes(params.targetFulfiller));
+  } else {
+    zone = NET_SEAPORT_ZONE_ADDRESS;
+    zoneHash = ZERO_BYTES322;
+  }
+  const orderParameters = {
+    offerer: params.offerer,
+    zone,
+    offer: [
+      {
+        itemType: 2 /* ERC721 */,
+        token: params.nftAddress,
+        identifierOrCriteria: BigInt(params.tokenId),
+        startAmount: BigInt(1),
+        endAmount: BigInt(1)
+      }
+    ],
+    consideration,
+    orderType: 2 /* FULL_RESTRICTED */,
+    startTime: BigInt(0),
+    endTime,
+    zoneHash,
+    salt: generateSalt(),
+    conduitKey: ZERO_BYTES322,
+    totalOriginalConsiderationItems: BigInt(consideration.length)
+  };
+  return { orderParameters, counter };
+}
+function buildCollectionOfferOrderComponents(params, chainId, counter) {
+  const weth = getWrappedNativeCurrency(chainId);
+  if (!weth) {
+    throw new Error(`No wrapped native currency configured for chain ${chainId}`);
+  }
+  const feeBps = getNftFeeBps(chainId);
+  const feeAmount = calculateFee(params.priceWei, feeBps, false);
+  const endTime = BigInt(params.expirationDate ?? getDefaultExpiration());
+  const feeCollector = getFeeCollectorAddress(chainId);
+  const consideration = [
+    {
+      itemType: 4 /* ERC721_WITH_CRITERIA */,
+      token: params.nftAddress,
+      identifierOrCriteria: BigInt(0),
+      // Any token in the collection
+      startAmount: BigInt(1),
+      endAmount: BigInt(1),
+      recipient: params.offerer
+    }
+  ];
+  if (feeAmount > BigInt(0)) {
+    consideration.push({
+      itemType: 1 /* ERC20 */,
+      token: weth.address,
+      identifierOrCriteria: BigInt(0),
+      startAmount: feeAmount,
+      endAmount: feeAmount,
+      recipient: feeCollector
+    });
+  }
+  const orderParameters = {
+    offerer: params.offerer,
+    zone: NET_SEAPORT_COLLECTION_OFFER_ZONE_ADDRESS,
+    offer: [
+      {
+        itemType: 1 /* ERC20 */,
+        token: weth.address,
+        identifierOrCriteria: BigInt(0),
+        startAmount: params.priceWei,
+        endAmount: params.priceWei
+      }
+    ],
+    consideration,
+    orderType: 2 /* FULL_RESTRICTED */,
+    startTime: BigInt(0),
+    endTime,
+    zoneHash: ZERO_BYTES322,
+    salt: generateSalt(),
+    conduitKey: ZERO_BYTES322,
+    totalOriginalConsiderationItems: BigInt(consideration.length)
+  };
+  return { orderParameters, counter };
+}
+function buildErc20OfferOrderComponents(params, chainId, counter) {
+  const weth = getWrappedNativeCurrency(chainId);
+  if (!weth) {
+    throw new Error(`No wrapped native currency configured for chain ${chainId}`);
+  }
+  const feeBps = getNftFeeBps(chainId);
+  const feeAmount = calculateFee(params.priceWei, feeBps, true);
+  const endTime = BigInt(params.expirationDate ?? getDefaultExpiration());
+  const feeCollector = getFeeCollectorAddress(chainId);
+  const consideration = [
+    {
+      itemType: 1 /* ERC20 */,
+      token: params.tokenAddress,
+      identifierOrCriteria: BigInt(0),
+      startAmount: params.tokenAmount,
+      endAmount: params.tokenAmount,
+      recipient: params.offerer
+    }
+  ];
+  if (feeAmount > BigInt(0)) {
+    consideration.push({
+      itemType: 1 /* ERC20 */,
+      token: weth.address,
+      identifierOrCriteria: BigInt(0),
+      startAmount: feeAmount,
+      endAmount: feeAmount,
+      recipient: feeCollector
+    });
+  }
+  const orderParameters = {
+    offerer: params.offerer,
+    zone: NET_SEAPORT_COLLECTION_OFFER_ZONE_ADDRESS,
+    offer: [
+      {
+        itemType: 1 /* ERC20 */,
+        token: weth.address,
+        identifierOrCriteria: BigInt(0),
+        startAmount: params.priceWei,
+        endAmount: params.priceWei
+      }
+    ],
+    consideration,
+    orderType: 2 /* FULL_RESTRICTED */,
+    startTime: BigInt(0),
+    endTime,
+    zoneHash: ZERO_BYTES322,
+    salt: generateSalt(),
+    conduitKey: ZERO_BYTES322,
+    totalOriginalConsiderationItems: BigInt(consideration.length)
+  };
+  return { orderParameters, counter };
+}
+function buildErc20ListingOrderComponents(params, chainId, counter) {
+  const feeBps = getNftFeeBps(chainId);
+  const feeAmount = calculateFee(params.priceWei, feeBps, true);
+  const sellerAmount = params.priceWei - feeAmount;
+  const endTime = BigInt(params.expirationDate ?? getDefaultExpiration());
+  const feeCollector = getFeeCollectorAddress(chainId);
+  const consideration = [
+    {
+      itemType: 0 /* NATIVE */,
+      token: ZERO_ADDRESS,
+      identifierOrCriteria: BigInt(0),
+      startAmount: sellerAmount,
+      endAmount: sellerAmount,
+      recipient: params.offerer
+    }
+  ];
+  if (feeAmount > BigInt(0)) {
+    consideration.push({
+      itemType: 0 /* NATIVE */,
+      token: ZERO_ADDRESS,
+      identifierOrCriteria: BigInt(0),
+      startAmount: feeAmount,
+      endAmount: feeAmount,
+      recipient: feeCollector
+    });
+  }
+  let zone;
+  let zoneHash;
+  if (params.targetFulfiller) {
+    zone = NET_SEAPORT_PRIVATE_ORDER_ZONE_ADDRESS;
+    zoneHash = viem.keccak256(viem.toBytes(params.targetFulfiller));
+  } else {
+    zone = NET_SEAPORT_ZONE_ADDRESS;
+    zoneHash = ZERO_BYTES322;
+  }
+  const orderParameters = {
+    offerer: params.offerer,
+    zone,
+    offer: [
+      {
+        itemType: 1 /* ERC20 */,
+        token: params.tokenAddress,
+        identifierOrCriteria: BigInt(0),
+        startAmount: params.tokenAmount,
+        endAmount: params.tokenAmount
+      }
+    ],
+    consideration,
+    orderType: 2 /* FULL_RESTRICTED */,
+    startTime: BigInt(0),
+    endTime,
+    zoneHash,
+    salt: generateSalt(),
+    conduitKey: ZERO_BYTES322,
+    totalOriginalConsiderationItems: BigInt(consideration.length)
+  };
+  return { orderParameters, counter };
+}
+function buildEIP712OrderData(orderParameters, counter, chainId, seaportAddress) {
+  const message = {
+    offerer: orderParameters.offerer,
+    zone: orderParameters.zone,
+    offer: orderParameters.offer.map((item) => ({
+      itemType: item.itemType,
+      token: item.token,
+      identifierOrCriteria: item.identifierOrCriteria,
+      startAmount: item.startAmount,
+      endAmount: item.endAmount
+    })),
+    consideration: orderParameters.consideration.map((item) => ({
+      itemType: item.itemType,
+      token: item.token,
+      identifierOrCriteria: item.identifierOrCriteria,
+      startAmount: item.startAmount,
+      endAmount: item.endAmount,
+      recipient: item.recipient
+    })),
+    orderType: orderParameters.orderType,
+    startTime: orderParameters.startTime,
+    endTime: orderParameters.endTime,
+    zoneHash: orderParameters.zoneHash,
+    salt: orderParameters.salt,
+    conduitKey: orderParameters.conduitKey,
+    counter
+  };
+  return {
+    domain: {
+      name: SEAPORT_EIP712_DOMAIN_NAME,
+      version: SEAPORT_EIP712_DOMAIN_VERSION,
+      chainId,
+      verifyingContract: seaportAddress
+    },
+    types: SEAPORT_ORDER_EIP712_TYPES,
+    primaryType: "OrderComponents",
+    message,
+    orderParameters,
+    counter
+  };
+}
+function buildSubmitOrderTx(contractAddress, abi, orderParameters, counter, signature) {
+  const submission = {
+    parameters: {
+      offerer: orderParameters.offerer,
+      zone: orderParameters.zone,
+      offer: orderParameters.offer.map((item) => ({
+        itemType: item.itemType,
+        token: item.token,
+        identifierOrCriteria: item.identifierOrCriteria,
+        startAmount: item.startAmount,
+        endAmount: item.endAmount
+      })),
+      consideration: orderParameters.consideration.map((item) => ({
+        itemType: item.itemType,
+        token: item.token,
+        identifierOrCriteria: item.identifierOrCriteria,
+        startAmount: item.startAmount,
+        endAmount: item.endAmount,
+        recipient: item.recipient
+      })),
+      orderType: orderParameters.orderType,
+      startTime: orderParameters.startTime,
+      endTime: orderParameters.endTime,
+      zoneHash: orderParameters.zoneHash,
+      salt: orderParameters.salt,
+      conduitKey: orderParameters.conduitKey,
+      totalOriginalConsiderationItems: orderParameters.totalOriginalConsiderationItems
+    },
+    counter,
+    signature
+  };
+  return {
+    to: contractAddress,
+    functionName: "submit",
+    args: [submission],
+    abi
+  };
+}
+var ERC721_TOKEN_OWNER_RANGE_HELPER_ADDRESS = "0x00000000f4ec2016d6e856b0cb14d635949bfd3f";
+var ERC721_TOKEN_OWNER_RANGE_HELPER_ABI = [
+  {
+    inputs: [
+      { name: "nftContract", type: "address" },
+      { name: "user", type: "address" },
+      { name: "startTokenId", type: "uint256" },
+      { name: "endTokenId", type: "uint256" }
+    ],
+    name: "getOwnedTokensInRange",
+    outputs: [{ name: "", type: "uint256[]" }],
+    stateMutability: "view",
+    type: "function"
+  }
+];
+var OWNED_TOKENS_BATCH_SIZE = 5000n;
 var CHAIN_RPC_URLS = {
   8453: ["https://base-mainnet.public.blastapi.io", "https://mainnet.base.org"],
   84532: ["https://sepolia.base.org"],
@@ -1154,7 +1891,7 @@ var BazaarClient = class {
     const bazaarAddress = getBazaarAddress(this.chainId);
     const filter = {
       appAddress: bazaarAddress,
-      topic: nftAddress.toLowerCase(),
+      topic: nftAddress?.toLowerCase(),
       maker
     };
     let startIndex;
@@ -1227,18 +1964,57 @@ var BazaarClient = class {
     }
     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);
+    let validOpenListings;
     const beforeOwnership = openListings.length;
-    const validOpenListings = openListings.filter((listing, index) => {
-      const owner = owners[index];
-      return isListingValid(
-        listing.orderStatus,
-        listing.expirationDate,
-        listing.maker,
-        owner
+    if (nftAddress) {
+      const tokenIds = openListings.map((l) => l.tokenId);
+      const owners = await bulkFetchNftOwners(this.client, nftAddress, tokenIds);
+      validOpenListings = openListings.filter((listing, index) => {
+        const owner = owners[index];
+        return isListingValid(
+          listing.orderStatus,
+          listing.expirationDate,
+          listing.maker,
+          owner
+        );
+      });
+    } else {
+      const groups = /* @__PURE__ */ new Map();
+      for (const listing of openListings) {
+        const key = listing.nftAddress.toLowerCase();
+        const group = groups.get(key);
+        if (group) {
+          group.push(listing);
+        } else {
+          groups.set(key, [listing]);
+        }
+      }
+      const groupEntries = Array.from(groups.entries());
+      const ownerResults = await Promise.all(
+        groupEntries.map(
+          ([addr, groupListings]) => bulkFetchNftOwners(
+            this.client,
+            addr,
+            groupListings.map((l) => l.tokenId)
+          )
+        )
       );
-    });
+      validOpenListings = [];
+      groupEntries.forEach(([, groupListings], groupIndex) => {
+        const owners = ownerResults[groupIndex];
+        for (let i = 0; i < groupListings.length; i++) {
+          const listing = groupListings[i];
+          if (isListingValid(
+            listing.orderStatus,
+            listing.expirationDate,
+            listing.maker,
+            owners[i]
+          )) {
+            validOpenListings.push(listing);
+          }
+        }
+      });
+    }
     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}`));
@@ -1750,16 +2526,303 @@ var BazaarClient = class {
       abi: SEAPORT_CANCEL_ABI
     };
   }
+  // ─── Fulfillment Methods ───────────────────────────────────────────
+  /**
+   * Prepare a fulfillment for an NFT listing (buy an NFT).
+   *
+   * Returns approval transactions (if the listing requires ERC20 payment) and
+   * the Seaport `fulfillAdvancedOrder` transaction with the correct native currency value.
+   */
+  async prepareFulfillListing(listing, fulfillerAddress) {
+    const submission = decodeSeaportSubmission(listing.messageData);
+    const seaportAddress = getSeaportAddress(this.chainId);
+    const fulfillment = buildFulfillListingTx(submission, fulfillerAddress, seaportAddress);
+    return { approvals: [], fulfillment };
+  }
+  /**
+   * Prepare a fulfillment for a collection offer (sell your NFT into an offer).
+   *
+   * Returns ERC721 approval transaction (if the NFT isn't approved for Seaport)
+   * and the Seaport `fulfillAdvancedOrder` transaction.
+   */
+  async prepareFulfillCollectionOffer(offer, tokenId, fulfillerAddress) {
+    const submission = decodeSeaportSubmission(offer.messageData);
+    const seaportAddress = getSeaportAddress(this.chainId);
+    const approvals = [];
+    const nftApproval = await checkErc721Approval(
+      this.client,
+      offer.nftAddress,
+      fulfillerAddress,
+      seaportAddress
+    );
+    if (nftApproval) {
+      approvals.push(nftApproval);
+    }
+    const fulfillment = buildFulfillCollectionOfferTx(
+      submission,
+      BigInt(tokenId),
+      fulfillerAddress,
+      seaportAddress
+    );
+    return { approvals, fulfillment };
+  }
+  /**
+   * Prepare a fulfillment for an ERC20 offer (sell your ERC20 tokens into an offer).
+   *
+   * Returns ERC20 approval transaction (if the token isn't approved for Seaport)
+   * and the Seaport `fulfillOrder` transaction.
+   */
+  async prepareFulfillErc20Offer(offer, fulfillerAddress) {
+    const submission = decodeSeaportSubmission(offer.messageData);
+    const seaportAddress = getSeaportAddress(this.chainId);
+    const approvals = [];
+    const tokenApproval = await checkErc20Approval(
+      this.client,
+      offer.tokenAddress,
+      fulfillerAddress,
+      seaportAddress,
+      offer.tokenAmount
+    );
+    if (tokenApproval) {
+      approvals.push(tokenApproval);
+    }
+    const fulfillment = buildFulfillErc20OfferTx(submission, seaportAddress);
+    return { approvals, fulfillment };
+  }
+  /**
+   * Prepare a fulfillment for an ERC20 listing (buy ERC20 tokens with native currency).
+   *
+   * Returns the Seaport `fulfillAdvancedOrder` transaction with the correct native currency value.
+   * No approvals needed since the buyer pays in native currency.
+   */
+  async prepareFulfillErc20Listing(listing, fulfillerAddress) {
+    const submission = decodeSeaportSubmission(listing.messageData);
+    const seaportAddress = getSeaportAddress(this.chainId);
+    const fulfillment = buildFulfillErc20ListingTx(submission, fulfillerAddress, seaportAddress);
+    return { approvals: [], fulfillment };
+  }
+  // ─── Order Creation Methods (Step 1: Build EIP-712 data) ──────────
+  /**
+   * Fetch the Seaport counter for an address
+   */
+  async getSeaportCounter(offerer) {
+    const seaportAddress = getSeaportAddress(this.chainId);
+    const counter = await actions.readContract(this.client, {
+      address: seaportAddress,
+      abi: SEAPORT_GET_COUNTER_ABI,
+      functionName: "getCounter",
+      args: [offerer]
+    });
+    return BigInt(counter);
+  }
+  /**
+   * Prepare an NFT listing order for signing.
+   *
+   * Returns EIP-712 typed data for the caller to sign, plus any maker approvals needed
+   * (ERC721 `setApprovalForAll` for Seaport).
+   */
+  async prepareCreateListing(params) {
+    const seaportAddress = getSeaportAddress(this.chainId);
+    const counter = await this.getSeaportCounter(params.offerer);
+    const { orderParameters } = buildListingOrderComponents(params, this.chainId, counter);
+    const eip712 = buildEIP712OrderData(orderParameters, counter, this.chainId, seaportAddress);
+    const approvals = [];
+    const nftApproval = await checkErc721Approval(
+      this.client,
+      params.nftAddress,
+      params.offerer,
+      seaportAddress
+    );
+    if (nftApproval) {
+      approvals.push(nftApproval);
+    }
+    return { eip712, approvals };
+  }
+  /**
+   * Prepare a collection offer order for signing.
+   *
+   * Returns EIP-712 typed data for the caller to sign, plus any maker approvals needed
+   * (WETH `approve` for Seaport).
+   */
+  async prepareCreateCollectionOffer(params) {
+    const seaportAddress = getSeaportAddress(this.chainId);
+    const weth = getWrappedNativeCurrency(this.chainId);
+    if (!weth) {
+      throw new Error(`No wrapped native currency configured for chain ${this.chainId}`);
+    }
+    const counter = await this.getSeaportCounter(params.offerer);
+    const { orderParameters } = buildCollectionOfferOrderComponents(params, this.chainId, counter);
+    const eip712 = buildEIP712OrderData(orderParameters, counter, this.chainId, seaportAddress);
+    const approvals = [];
+    const wethApproval = await checkErc20Approval(
+      this.client,
+      weth.address,
+      params.offerer,
+      seaportAddress,
+      params.priceWei
+    );
+    if (wethApproval) {
+      approvals.push(wethApproval);
+    }
+    return { eip712, approvals };
+  }
+  /**
+   * Prepare an ERC20 offer order for signing.
+   *
+   * Returns EIP-712 typed data for the caller to sign, plus any maker approvals needed
+   * (WETH `approve` for Seaport).
+   */
+  async prepareCreateErc20Offer(params) {
+    const seaportAddress = getSeaportAddress(this.chainId);
+    const weth = getWrappedNativeCurrency(this.chainId);
+    if (!weth) {
+      throw new Error(`No wrapped native currency configured for chain ${this.chainId}`);
+    }
+    const counter = await this.getSeaportCounter(params.offerer);
+    const { orderParameters } = buildErc20OfferOrderComponents(params, this.chainId, counter);
+    const eip712 = buildEIP712OrderData(orderParameters, counter, this.chainId, seaportAddress);
+    const approvals = [];
+    const wethApproval = await checkErc20Approval(
+      this.client,
+      weth.address,
+      params.offerer,
+      seaportAddress,
+      params.priceWei
+    );
+    if (wethApproval) {
+      approvals.push(wethApproval);
+    }
+    return { eip712, approvals };
+  }
+  /**
+   * Prepare an ERC20 listing order for signing.
+   *
+   * Returns EIP-712 typed data for the caller to sign, plus any maker approvals needed
+   * (ERC20 `approve` for Seaport).
+   */
+  async prepareCreateErc20Listing(params) {
+    const seaportAddress = getSeaportAddress(this.chainId);
+    const counter = await this.getSeaportCounter(params.offerer);
+    const { orderParameters } = buildErc20ListingOrderComponents(params, this.chainId, counter);
+    const eip712 = buildEIP712OrderData(orderParameters, counter, this.chainId, seaportAddress);
+    const approvals = [];
+    const tokenApproval = await checkErc20Approval(
+      this.client,
+      params.tokenAddress,
+      params.offerer,
+      seaportAddress,
+      params.tokenAmount
+    );
+    if (tokenApproval) {
+      approvals.push(tokenApproval);
+    }
+    return { eip712, approvals };
+  }
+  // ─── Order Creation Methods (Step 2: Submit signed order) ─────────
+  /**
+   * Prepare a submit transaction for an NFT listing.
+   *
+   * Call this after the user has signed the EIP-712 data from prepareCreateListing().
+   */
+  prepareSubmitListing(orderParameters, counter, signature) {
+    return buildSubmitOrderTx(
+      getBazaarAddress(this.chainId),
+      BAZAAR_V2_ABI,
+      orderParameters,
+      counter,
+      signature
+    );
+  }
+  /**
+   * Prepare a submit transaction for a collection offer.
+   *
+   * Call this after the user has signed the EIP-712 data from prepareCreateCollectionOffer().
+   */
+  prepareSubmitCollectionOffer(orderParameters, counter, signature) {
+    return buildSubmitOrderTx(
+      getCollectionOffersAddress(this.chainId),
+      BAZAAR_COLLECTION_OFFERS_ABI,
+      orderParameters,
+      counter,
+      signature
+    );
+  }
+  /**
+   * Prepare a submit transaction for an ERC20 offer.
+   *
+   * Call this after the user has signed the EIP-712 data from prepareCreateErc20Offer().
+   */
+  prepareSubmitErc20Offer(orderParameters, counter, signature) {
+    const erc20OffersAddress = getErc20OffersAddress(this.chainId);
+    if (!erc20OffersAddress) {
+      throw new Error(`ERC20 offers not available on chain ${this.chainId}`);
+    }
+    return buildSubmitOrderTx(
+      erc20OffersAddress,
+      BAZAAR_ERC20_OFFERS_ABI,
+      orderParameters,
+      counter,
+      signature
+    );
+  }
+  /**
+   * Prepare a submit transaction for an ERC20 listing.
+   *
+   * Call this after the user has signed the EIP-712 data from prepareCreateErc20Listing().
+   */
+  prepareSubmitErc20Listing(orderParameters, counter, signature) {
+    return buildSubmitOrderTx(
+      getErc20BazaarAddress(this.chainId),
+      BAZAAR_V2_ABI,
+      orderParameters,
+      counter,
+      signature
+    );
+  }
+  // ─── Owned Tokens Query ─────────────────────────────────────────────
+  /**
+   * Get token IDs owned by an address for an ERC721 collection.
+   *
+   * Uses the on-chain ERC721TokenOwnerRangeHelper contract, batching
+   * large ranges into 5000-token chunks to avoid RPC limits.
+   */
+  async getOwnedTokens(params) {
+    const { nftAddress, ownerAddress } = params;
+    const startTokenId = params.startTokenId ?? 0n;
+    const endTokenId = params.endTokenId ?? 10000n;
+    const ownedTokens = [];
+    let current = startTokenId;
+    while (current < endTokenId) {
+      const batchEnd = current + OWNED_TOKENS_BATCH_SIZE < endTokenId ? current + OWNED_TOKENS_BATCH_SIZE : endTokenId;
+      try {
+        const result = await actions.readContract(this.client, {
+          address: ERC721_TOKEN_OWNER_RANGE_HELPER_ADDRESS,
+          abi: ERC721_TOKEN_OWNER_RANGE_HELPER_ABI,
+          functionName: "getOwnedTokensInRange",
+          args: [nftAddress, ownerAddress, current, batchEnd]
+        });
+        for (const tokenId of result) {
+          ownedTokens.push(tokenId);
+        }
+      } catch {
+      }
+      current = batchEnd;
+    }
+    return ownedTokens;
+  }
 };
 
 exports.BAZAAR_COLLECTION_OFFERS_ABI = BAZAAR_COLLECTION_OFFERS_ABI;
+exports.BAZAAR_ERC20_OFFERS_ABI = BAZAAR_ERC20_OFFERS_ABI;
 exports.BAZAAR_SUBMISSION_ABI = BAZAAR_SUBMISSION_ABI;
 exports.BAZAAR_V2_ABI = BAZAAR_V2_ABI;
 exports.BULK_SEAPORT_ORDER_STATUS_FETCHER_ABI = BULK_SEAPORT_ORDER_STATUS_FETCHER_ABI;
 exports.BULK_SEAPORT_ORDER_STATUS_FETCHER_ADDRESS = BULK_SEAPORT_ORDER_STATUS_FETCHER_ADDRESS;
 exports.BazaarClient = BazaarClient;
+exports.ERC20_APPROVAL_ABI = ERC20_APPROVAL_ABI;
 exports.ERC20_BULK_BALANCE_CHECKER_ABI = ERC20_BULK_BALANCE_CHECKER_ABI;
 exports.ERC20_BULK_BALANCE_CHECKER_ADDRESS = ERC20_BULK_BALANCE_CHECKER_ADDRESS;
+exports.ERC721_APPROVAL_ABI = ERC721_APPROVAL_ABI;
 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;
@@ -1768,10 +2831,26 @@ exports.NET_SEAPORT_PRIVATE_ORDER_ZONE_ADDRESS = NET_SEAPORT_PRIVATE_ORDER_ZONE_
 exports.NET_SEAPORT_ZONE_ADDRESS = NET_SEAPORT_ZONE_ADDRESS;
 exports.OrderType = OrderType;
 exports.SEAPORT_CANCEL_ABI = SEAPORT_CANCEL_ABI;
+exports.SEAPORT_FULFILL_ADVANCED_ORDER_ABI = SEAPORT_FULFILL_ADVANCED_ORDER_ABI;
+exports.SEAPORT_FULFILL_ORDER_ABI = SEAPORT_FULFILL_ORDER_ABI;
+exports.SEAPORT_GET_COUNTER_ABI = SEAPORT_GET_COUNTER_ABI;
 exports.SeaportOrderStatus = SeaportOrderStatus;
+exports.buildCollectionOfferOrderComponents = buildCollectionOfferOrderComponents;
+exports.buildEIP712OrderData = buildEIP712OrderData;
+exports.buildErc20ListingOrderComponents = buildErc20ListingOrderComponents;
+exports.buildErc20OfferOrderComponents = buildErc20OfferOrderComponents;
+exports.buildFulfillCollectionOfferTx = buildFulfillCollectionOfferTx;
+exports.buildFulfillErc20ListingTx = buildFulfillErc20ListingTx;
+exports.buildFulfillErc20OfferTx = buildFulfillErc20OfferTx;
+exports.buildFulfillListingTx = buildFulfillListingTx;
+exports.buildListingOrderComponents = buildListingOrderComponents;
+exports.buildSubmitOrderTx = buildSubmitOrderTx;
 exports.bulkFetchErc20Balances = bulkFetchErc20Balances;
 exports.bulkFetchNftOwners = bulkFetchNftOwners;
 exports.bulkFetchOrderStatuses = bulkFetchOrderStatuses;
+exports.calculateFee = calculateFee;
+exports.checkErc20Approval = checkErc20Approval;
+exports.checkErc721Approval = checkErc721Approval;
 exports.computeOrderHash = computeOrderHash;
 exports.createBalanceMap = createBalanceMap;
 exports.createOrderStatusMap = createOrderStatusMap;
@@ -1779,6 +2858,7 @@ exports.createOwnershipMap = createOwnershipMap;
 exports.createSeaportInstance = createSeaportInstance;
 exports.decodeSeaportSubmission = decodeSeaportSubmission;
 exports.formatPrice = formatPrice;
+exports.generateSalt = generateSalt;
 exports.getBazaarAddress = getBazaarAddress;
 exports.getBazaarChainConfig = getBazaarChainConfig;
 exports.getBazaarSupportedChainIds = getBazaarSupportedChainIds;
@@ -1786,6 +2866,7 @@ exports.getBestCollectionOffer = getBestCollectionOffer;
 exports.getBestListingPerToken = getBestListingPerToken;
 exports.getCollectionOffersAddress = getCollectionOffersAddress;
 exports.getCurrencySymbol = getCurrencySymbol;
+exports.getDefaultExpiration = getDefaultExpiration;
 exports.getErc20BazaarAddress = getErc20BazaarAddress;
 exports.getErc20OffersAddress = getErc20OffersAddress;
 exports.getFeeCollectorAddress = getFeeCollectorAddress;