@net-protocol/cli 0.1.9 → 0.1.11

package/dist/cli/index.mjs

@@ -15,6 +15,7 @@ import { isNetrSupportedChain, NetrClient } from '@net-protocol/netr';
 import { PROFILE_PICTURE_STORAGE_KEY, PROFILE_METADATA_STORAGE_KEY, parseProfileMetadata, PROFILE_CANVAS_STORAGE_KEY, isValidUrl, getProfilePictureStorageArgs, STORAGE_CONTRACT, isValidXUsername, getXUsernameStorageArgs, isValidBio, getProfileMetadataStorageArgs } from '@net-protocol/profiles';
 import { base } from 'viem/chains';
 import * as path from 'path';
+import { BazaarClient } from '@net-protocol/bazaar';
 
 function getRequiredChainId(optionValue) {
   const chainId = optionValue || (process.env.NET_CHAIN_ID ? parseInt(process.env.NET_CHAIN_ID, 10) : void 0);
@@ -1477,8 +1478,8 @@ function registerStorageCommand(program2) {
       console.log(chalk4.blue(`\u{1F4C1} Reading file: ${options.file}`));
       console.log(chalk4.blue(`\u{1F517} Using relay API: ${options.apiUrl}`));
       const result = await uploadFileWithRelay(uploadRelayOptions);
-      const { privateKeyToAccount: privateKeyToAccount10 } = await import('viem/accounts');
-      const userAccount = privateKeyToAccount10(commonOptions.privateKey);
+      const { privateKeyToAccount: privateKeyToAccount16 } = await import('viem/accounts');
+      const userAccount = privateKeyToAccount16(commonOptions.privateKey);
       const storageUrl = generateStorageUrl(
         userAccount.address,
         commonOptions.chainId,
@@ -2935,6 +2936,1045 @@ function registerProfileCommand(program2) {
   profileCommand.addCommand(getCanvasCommand);
 }
 
+// src/commands/bazaar/format.ts
+function formatEthPrice(price) {
+  return price.toFixed(6).replace(/\.?0+$/, "");
+}
+
+// src/commands/bazaar/list-listings.ts
+async function executeListListings(options) {
+  const readOnlyOptions = parseReadOnlyOptions({
+    chainId: options.chainId,
+    rpcUrl: options.rpcUrl
+  });
+  const bazaarClient = new BazaarClient({
+    chainId: readOnlyOptions.chainId,
+    rpcUrl: readOnlyOptions.rpcUrl
+  });
+  try {
+    const listings = await bazaarClient.getListings({
+      nftAddress: options.nftAddress
+    });
+    if (options.json) {
+      const output = listings.map((l) => ({
+        orderHash: l.orderHash,
+        maker: l.maker,
+        nftAddress: l.nftAddress,
+        tokenId: l.tokenId,
+        price: l.price,
+        priceWei: l.priceWei.toString(),
+        currency: l.currency,
+        expirationDate: l.expirationDate,
+        orderStatus: l.orderStatus,
+        ...l.targetFulfiller ? { targetFulfiller: l.targetFulfiller } : {}
+      }));
+      console.log(JSON.stringify(output, null, 2));
+      return;
+    }
+    if (listings.length === 0) {
+      console.log(chalk4.yellow("No active listings found"));
+      return;
+    }
+    console.log(chalk4.white.bold(`
+Listings (${listings.length}):
+`));
+    for (const listing of listings) {
+      const expiry = new Date(listing.expirationDate * 1e3).toLocaleString();
+      console.log(`  ${chalk4.cyan("Order Hash:")} ${listing.orderHash}`);
+      console.log(`  ${chalk4.cyan("Seller:")} ${listing.maker}`);
+      console.log(`  ${chalk4.cyan("NFT:")} ${listing.nftAddress} #${listing.tokenId}`);
+      console.log(`  ${chalk4.cyan("Price:")} ${formatEthPrice(listing.price)} ${listing.currency.toUpperCase()}`);
+      console.log(`  ${chalk4.cyan("Expires:")} ${expiry}`);
+      if (listing.targetFulfiller) {
+        console.log(`  ${chalk4.cyan("Private (for):")} ${listing.targetFulfiller}`);
+      }
+      console.log();
+    }
+  } catch (error) {
+    exitWithError(
+      `Failed to fetch listings: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+async function executeListOffers(options) {
+  const readOnlyOptions = parseReadOnlyOptions({
+    chainId: options.chainId,
+    rpcUrl: options.rpcUrl
+  });
+  const bazaarClient = new BazaarClient({
+    chainId: readOnlyOptions.chainId,
+    rpcUrl: readOnlyOptions.rpcUrl
+  });
+  try {
+    const offers = await bazaarClient.getCollectionOffers({
+      nftAddress: options.nftAddress
+    });
+    if (options.json) {
+      const output = offers.map((o) => ({
+        orderHash: o.orderHash,
+        maker: o.maker,
+        nftAddress: o.nftAddress,
+        price: o.price,
+        priceWei: o.priceWei.toString(),
+        currency: o.currency,
+        expirationDate: o.expirationDate,
+        orderStatus: o.orderStatus
+      }));
+      console.log(JSON.stringify(output, null, 2));
+      return;
+    }
+    if (offers.length === 0) {
+      console.log(chalk4.yellow("No active collection offers found"));
+      return;
+    }
+    console.log(chalk4.white.bold(`
+Collection Offers (${offers.length}):
+`));
+    for (const offer of offers) {
+      const expiry = new Date(offer.expirationDate * 1e3).toLocaleString();
+      console.log(`  ${chalk4.cyan("Order Hash:")} ${offer.orderHash}`);
+      console.log(`  ${chalk4.cyan("Buyer:")} ${offer.maker}`);
+      console.log(`  ${chalk4.cyan("Collection:")} ${offer.nftAddress}`);
+      console.log(`  ${chalk4.cyan("Price:")} ${formatEthPrice(offer.price)} ${offer.currency.toUpperCase()}`);
+      console.log(`  ${chalk4.cyan("Expires:")} ${expiry}`);
+      console.log();
+    }
+  } catch (error) {
+    exitWithError(
+      `Failed to fetch offers: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+async function executeListSales(options) {
+  const readOnlyOptions = parseReadOnlyOptions({
+    chainId: options.chainId,
+    rpcUrl: options.rpcUrl
+  });
+  const bazaarClient = new BazaarClient({
+    chainId: readOnlyOptions.chainId,
+    rpcUrl: readOnlyOptions.rpcUrl
+  });
+  try {
+    const sales = await bazaarClient.getSales({
+      nftAddress: options.nftAddress
+    });
+    if (options.json) {
+      const output = sales.map((s) => ({
+        orderHash: s.orderHash,
+        seller: s.seller,
+        buyer: s.buyer,
+        tokenAddress: s.tokenAddress,
+        tokenId: s.tokenId,
+        amount: s.amount.toString(),
+        price: s.price,
+        priceWei: s.priceWei.toString(),
+        currency: s.currency,
+        timestamp: s.timestamp
+      }));
+      console.log(JSON.stringify(output, null, 2));
+      return;
+    }
+    if (sales.length === 0) {
+      console.log(chalk4.yellow("No sales found"));
+      return;
+    }
+    console.log(chalk4.white.bold(`
+Sales (${sales.length}):
+`));
+    for (const sale of sales) {
+      const date = new Date(sale.timestamp * 1e3).toLocaleString();
+      console.log(`  ${chalk4.cyan("Order Hash:")} ${sale.orderHash}`);
+      console.log(`  ${chalk4.cyan("Seller:")} ${sale.seller}`);
+      console.log(`  ${chalk4.cyan("Buyer:")} ${sale.buyer}`);
+      console.log(`  ${chalk4.cyan("Token:")} ${sale.tokenAddress} #${sale.tokenId}`);
+      console.log(`  ${chalk4.cyan("Price:")} ${formatEthPrice(sale.price)} ${sale.currency.toUpperCase()}`);
+      console.log(`  ${chalk4.cyan("Date:")} ${date}`);
+      console.log();
+    }
+  } catch (error) {
+    exitWithError(
+      `Failed to fetch sales: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+async function executeCreateListing(options) {
+  const hasPrivateKey = !!(options.privateKey || process.env.NET_PRIVATE_KEY || process.env.PRIVATE_KEY);
+  if (!hasPrivateKey) {
+    await executeKeylessMode(options);
+    return;
+  }
+  const commonOptions = parseCommonOptions({
+    privateKey: options.privateKey,
+    chainId: options.chainId,
+    rpcUrl: options.rpcUrl
+  });
+  const account = privateKeyToAccount(commonOptions.privateKey);
+  const bazaarClient = new BazaarClient({
+    chainId: commonOptions.chainId,
+    rpcUrl: commonOptions.rpcUrl
+  });
+  const priceWei = parseEther(options.price);
+  try {
+    console.log(chalk4.blue("Preparing listing..."));
+    const prepared = await bazaarClient.prepareCreateListing({
+      nftAddress: options.nftAddress,
+      tokenId: options.tokenId,
+      priceWei,
+      offerer: account.address,
+      targetFulfiller: options.targetFulfiller
+    });
+    const rpcUrls = getChainRpcUrls({
+      chainId: commonOptions.chainId,
+      rpcUrl: commonOptions.rpcUrl
+    });
+    const walletClient = createWalletClient({
+      account,
+      transport: http(rpcUrls[0])
+    });
+    for (const approval of prepared.approvals) {
+      console.log(chalk4.blue("Sending approval transaction..."));
+      const calldata = encodeFunctionData({
+        abi: approval.abi,
+        functionName: approval.functionName,
+        args: approval.args
+      });
+      const approvalHash = await walletClient.sendTransaction({
+        to: approval.to,
+        data: calldata,
+        chain: null,
+        value: approval.value
+      });
+      console.log(chalk4.green(`Approval tx: ${approvalHash}`));
+    }
+    console.log(chalk4.blue("Signing order..."));
+    const signature = await walletClient.signTypedData({
+      domain: prepared.eip712.domain,
+      types: prepared.eip712.types,
+      primaryType: prepared.eip712.primaryType,
+      message: prepared.eip712.message
+    });
+    console.log(chalk4.blue("Submitting listing..."));
+    const submitTx = bazaarClient.prepareSubmitListing(
+      prepared.eip712.orderParameters,
+      prepared.eip712.counter,
+      signature
+    );
+    const submitCalldata = encodeFunctionData({
+      abi: submitTx.abi,
+      functionName: submitTx.functionName,
+      args: submitTx.args
+    });
+    const hash = await walletClient.sendTransaction({
+      to: submitTx.to,
+      data: submitCalldata,
+      chain: null,
+      value: submitTx.value
+    });
+    console.log(
+      chalk4.green(
+        `Listing created successfully!
+  Transaction: ${hash}
+  NFT: ${options.nftAddress} #${options.tokenId}
+  Price: ${options.price} ETH`
+      )
+    );
+  } catch (error) {
+    exitWithError(
+      `Failed to create listing: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+async function executeKeylessMode(options) {
+  if (!options.offerer) {
+    exitWithError("--offerer is required when not providing --private-key");
+  }
+  const readOnlyOptions = parseReadOnlyOptions({
+    chainId: options.chainId,
+    rpcUrl: options.rpcUrl
+  });
+  const bazaarClient = new BazaarClient({
+    chainId: readOnlyOptions.chainId,
+    rpcUrl: readOnlyOptions.rpcUrl
+  });
+  const priceWei = parseEther(options.price);
+  try {
+    const prepared = await bazaarClient.prepareCreateListing({
+      nftAddress: options.nftAddress,
+      tokenId: options.tokenId,
+      priceWei,
+      offerer: options.offerer,
+      targetFulfiller: options.targetFulfiller
+    });
+    const output = {
+      eip712: {
+        domain: prepared.eip712.domain,
+        types: prepared.eip712.types,
+        primaryType: prepared.eip712.primaryType,
+        message: prepared.eip712.message
+      },
+      orderParameters: prepared.eip712.orderParameters,
+      counter: prepared.eip712.counter.toString(),
+      approvals: prepared.approvals.map((a) => ({
+        to: a.to,
+        data: encodeFunctionData({
+          abi: a.abi,
+          functionName: a.functionName,
+          args: a.args
+        }),
+        description: `Approve ${a.functionName}`
+      }))
+    };
+    console.log(JSON.stringify(output, bigintReplacer, 2));
+  } catch (error) {
+    exitWithError(
+      `Failed to prepare listing: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+function bigintReplacer(_key, value) {
+  if (typeof value === "bigint") {
+    return value.toString();
+  }
+  return value;
+}
+async function executeCreateOffer(options) {
+  const hasPrivateKey = !!(options.privateKey || process.env.NET_PRIVATE_KEY || process.env.PRIVATE_KEY);
+  if (!hasPrivateKey) {
+    await executeKeylessMode2(options);
+    return;
+  }
+  const commonOptions = parseCommonOptions({
+    privateKey: options.privateKey,
+    chainId: options.chainId,
+    rpcUrl: options.rpcUrl
+  });
+  const account = privateKeyToAccount(commonOptions.privateKey);
+  const bazaarClient = new BazaarClient({
+    chainId: commonOptions.chainId,
+    rpcUrl: commonOptions.rpcUrl
+  });
+  const priceWei = parseEther(options.price);
+  try {
+    console.log(chalk4.blue("Preparing collection offer..."));
+    const prepared = await bazaarClient.prepareCreateCollectionOffer({
+      nftAddress: options.nftAddress,
+      priceWei,
+      offerer: account.address
+    });
+    const rpcUrls = getChainRpcUrls({
+      chainId: commonOptions.chainId,
+      rpcUrl: commonOptions.rpcUrl
+    });
+    const walletClient = createWalletClient({
+      account,
+      transport: http(rpcUrls[0])
+    });
+    for (const approval of prepared.approvals) {
+      console.log(chalk4.blue("Sending approval transaction..."));
+      const calldata = encodeFunctionData({
+        abi: approval.abi,
+        functionName: approval.functionName,
+        args: approval.args
+      });
+      const approvalHash = await walletClient.sendTransaction({
+        to: approval.to,
+        data: calldata,
+        chain: null,
+        value: approval.value
+      });
+      console.log(chalk4.green(`Approval tx: ${approvalHash}`));
+    }
+    console.log(chalk4.blue("Signing offer..."));
+    const signature = await walletClient.signTypedData({
+      domain: prepared.eip712.domain,
+      types: prepared.eip712.types,
+      primaryType: prepared.eip712.primaryType,
+      message: prepared.eip712.message
+    });
+    console.log(chalk4.blue("Submitting offer..."));
+    const submitTx = bazaarClient.prepareSubmitCollectionOffer(
+      prepared.eip712.orderParameters,
+      prepared.eip712.counter,
+      signature
+    );
+    const submitCalldata = encodeFunctionData({
+      abi: submitTx.abi,
+      functionName: submitTx.functionName,
+      args: submitTx.args
+    });
+    const hash = await walletClient.sendTransaction({
+      to: submitTx.to,
+      data: submitCalldata,
+      chain: null,
+      value: submitTx.value
+    });
+    console.log(
+      chalk4.green(
+        `Collection offer created successfully!
+  Transaction: ${hash}
+  Collection: ${options.nftAddress}
+  Price: ${options.price} ETH`
+      )
+    );
+  } catch (error) {
+    exitWithError(
+      `Failed to create offer: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+async function executeKeylessMode2(options) {
+  if (!options.offerer) {
+    exitWithError("--offerer is required when not providing --private-key");
+  }
+  const readOnlyOptions = parseReadOnlyOptions({
+    chainId: options.chainId,
+    rpcUrl: options.rpcUrl
+  });
+  const bazaarClient = new BazaarClient({
+    chainId: readOnlyOptions.chainId,
+    rpcUrl: readOnlyOptions.rpcUrl
+  });
+  const priceWei = parseEther(options.price);
+  try {
+    const prepared = await bazaarClient.prepareCreateCollectionOffer({
+      nftAddress: options.nftAddress,
+      priceWei,
+      offerer: options.offerer
+    });
+    const output = {
+      eip712: {
+        domain: prepared.eip712.domain,
+        types: prepared.eip712.types,
+        primaryType: prepared.eip712.primaryType,
+        message: prepared.eip712.message
+      },
+      orderParameters: prepared.eip712.orderParameters,
+      counter: prepared.eip712.counter.toString(),
+      approvals: prepared.approvals.map((a) => ({
+        to: a.to,
+        data: encodeFunctionData({
+          abi: a.abi,
+          functionName: a.functionName,
+          args: a.args
+        }),
+        description: `Approve ${a.functionName}`
+      }))
+    };
+    console.log(JSON.stringify(output, bigintReplacer2, 2));
+  } catch (error) {
+    exitWithError(
+      `Failed to prepare offer: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+function bigintReplacer2(_key, value) {
+  if (typeof value === "bigint") {
+    return value.toString();
+  }
+  return value;
+}
+async function executeSubmitListing(options) {
+  let orderData;
+  try {
+    const raw = readFileSync(options.orderData, "utf-8");
+    orderData = JSON.parse(raw);
+  } catch (error) {
+    exitWithError(
+      `Failed to read order data file: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+  if (options.encodeOnly) {
+    await executeEncodeOnly3(options, orderData);
+    return;
+  }
+  const commonOptions = parseCommonOptions(
+    {
+      privateKey: options.privateKey,
+      chainId: options.chainId,
+      rpcUrl: options.rpcUrl
+    },
+    true
+  );
+  const account = privateKeyToAccount(commonOptions.privateKey);
+  const bazaarClient = new BazaarClient({
+    chainId: commonOptions.chainId,
+    rpcUrl: commonOptions.rpcUrl
+  });
+  try {
+    const submitTx = bazaarClient.prepareSubmitListing(
+      orderData.orderParameters,
+      BigInt(orderData.counter),
+      options.signature
+    );
+    const rpcUrls = getChainRpcUrls({
+      chainId: commonOptions.chainId,
+      rpcUrl: commonOptions.rpcUrl
+    });
+    const walletClient = createWalletClient({
+      account,
+      transport: http(rpcUrls[0])
+    });
+    console.log(chalk4.blue("Submitting listing..."));
+    const calldata = encodeFunctionData({
+      abi: submitTx.abi,
+      functionName: submitTx.functionName,
+      args: submitTx.args
+    });
+    const hash = await walletClient.sendTransaction({
+      to: submitTx.to,
+      data: calldata,
+      chain: null,
+      value: submitTx.value
+    });
+    console.log(chalk4.green(`Listing submitted successfully!
+  Transaction: ${hash}`));
+  } catch (error) {
+    exitWithError(
+      `Failed to submit listing: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+async function executeEncodeOnly3(options, orderData) {
+  const readOnlyOptions = parseReadOnlyOptions({
+    chainId: options.chainId,
+    rpcUrl: options.rpcUrl
+  });
+  const bazaarClient = new BazaarClient({
+    chainId: readOnlyOptions.chainId,
+    rpcUrl: readOnlyOptions.rpcUrl
+  });
+  const submitTx = bazaarClient.prepareSubmitListing(
+    orderData.orderParameters,
+    BigInt(orderData.counter),
+    options.signature
+  );
+  const encoded = encodeTransaction(
+    { to: submitTx.to, functionName: submitTx.functionName, args: submitTx.args, abi: submitTx.abi, value: submitTx.value },
+    readOnlyOptions.chainId
+  );
+  console.log(JSON.stringify(encoded, null, 2));
+}
+async function executeSubmitOffer(options) {
+  let orderData;
+  try {
+    const raw = readFileSync(options.orderData, "utf-8");
+    orderData = JSON.parse(raw);
+  } catch (error) {
+    exitWithError(
+      `Failed to read order data file: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+  if (options.encodeOnly) {
+    await executeEncodeOnly4(options, orderData);
+    return;
+  }
+  const commonOptions = parseCommonOptions(
+    {
+      privateKey: options.privateKey,
+      chainId: options.chainId,
+      rpcUrl: options.rpcUrl
+    },
+    true
+  );
+  const account = privateKeyToAccount(commonOptions.privateKey);
+  const bazaarClient = new BazaarClient({
+    chainId: commonOptions.chainId,
+    rpcUrl: commonOptions.rpcUrl
+  });
+  try {
+    const submitTx = bazaarClient.prepareSubmitCollectionOffer(
+      orderData.orderParameters,
+      BigInt(orderData.counter),
+      options.signature
+    );
+    const rpcUrls = getChainRpcUrls({
+      chainId: commonOptions.chainId,
+      rpcUrl: commonOptions.rpcUrl
+    });
+    const walletClient = createWalletClient({
+      account,
+      transport: http(rpcUrls[0])
+    });
+    console.log(chalk4.blue("Submitting offer..."));
+    const calldata = encodeFunctionData({
+      abi: submitTx.abi,
+      functionName: submitTx.functionName,
+      args: submitTx.args
+    });
+    const hash = await walletClient.sendTransaction({
+      to: submitTx.to,
+      data: calldata,
+      chain: null,
+      value: submitTx.value
+    });
+    console.log(chalk4.green(`Offer submitted successfully!
+  Transaction: ${hash}`));
+  } catch (error) {
+    exitWithError(
+      `Failed to submit offer: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+async function executeEncodeOnly4(options, orderData) {
+  const readOnlyOptions = parseReadOnlyOptions({
+    chainId: options.chainId,
+    rpcUrl: options.rpcUrl
+  });
+  const bazaarClient = new BazaarClient({
+    chainId: readOnlyOptions.chainId,
+    rpcUrl: readOnlyOptions.rpcUrl
+  });
+  const submitTx = bazaarClient.prepareSubmitCollectionOffer(
+    orderData.orderParameters,
+    BigInt(orderData.counter),
+    options.signature
+  );
+  const encoded = encodeTransaction(
+    { to: submitTx.to, functionName: submitTx.functionName, args: submitTx.args, abi: submitTx.abi, value: submitTx.value },
+    readOnlyOptions.chainId
+  );
+  console.log(JSON.stringify(encoded, null, 2));
+}
+async function executeBuyListing(options) {
+  if (options.encodeOnly) {
+    await executeEncodeOnly5(options);
+    return;
+  }
+  const commonOptions = parseCommonOptions(
+    {
+      privateKey: options.privateKey,
+      chainId: options.chainId,
+      rpcUrl: options.rpcUrl
+    },
+    true
+  );
+  const account = privateKeyToAccount(commonOptions.privateKey);
+  const bazaarClient = new BazaarClient({
+    chainId: commonOptions.chainId,
+    rpcUrl: commonOptions.rpcUrl
+  });
+  try {
+    console.log(chalk4.blue("Fetching listing..."));
+    const listings = await bazaarClient.getListings({
+      nftAddress: options.nftAddress
+    });
+    const listing = listings.find(
+      (l) => l.orderHash.toLowerCase() === options.orderHash.toLowerCase()
+    );
+    if (!listing) {
+      exitWithError(`Listing with order hash ${options.orderHash} not found or no longer active`);
+    }
+    console.log(chalk4.blue("Preparing fulfillment..."));
+    const prepared = await bazaarClient.prepareFulfillListing(listing, account.address);
+    const rpcUrls = getChainRpcUrls({
+      chainId: commonOptions.chainId,
+      rpcUrl: commonOptions.rpcUrl
+    });
+    const walletClient = createWalletClient({
+      account,
+      transport: http(rpcUrls[0])
+    });
+    for (const approval of prepared.approvals) {
+      console.log(chalk4.blue("Sending approval transaction..."));
+      const calldata2 = encodeFunctionData({
+        abi: approval.abi,
+        functionName: approval.functionName,
+        args: approval.args
+      });
+      const approvalHash = await walletClient.sendTransaction({
+        to: approval.to,
+        data: calldata2,
+        chain: null,
+        value: approval.value
+      });
+      console.log(chalk4.green(`Approval tx: ${approvalHash}`));
+    }
+    console.log(chalk4.blue("Sending fulfillment transaction..."));
+    const calldata = encodeFunctionData({
+      abi: prepared.fulfillment.abi,
+      functionName: prepared.fulfillment.functionName,
+      args: prepared.fulfillment.args
+    });
+    const hash = await walletClient.sendTransaction({
+      to: prepared.fulfillment.to,
+      data: calldata,
+      chain: null,
+      value: prepared.fulfillment.value
+    });
+    console.log(
+      chalk4.green(
+        `Listing fulfilled successfully!
+  Transaction: ${hash}
+  NFT: ${listing.nftAddress} #${listing.tokenId}
+  Price: ${listing.price} ${listing.currency.toUpperCase()}`
+      )
+    );
+  } catch (error) {
+    exitWithError(
+      `Failed to buy listing: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+async function executeEncodeOnly5(options) {
+  if (!options.buyer) {
+    exitWithError("--buyer is required when using --encode-only without --private-key");
+  }
+  const readOnlyOptions = parseReadOnlyOptions({
+    chainId: options.chainId,
+    rpcUrl: options.rpcUrl
+  });
+  const buyerAddress = options.buyer;
+  const bazaarClient = new BazaarClient({
+    chainId: readOnlyOptions.chainId,
+    rpcUrl: readOnlyOptions.rpcUrl
+  });
+  try {
+    const listings = await bazaarClient.getListings({
+      nftAddress: options.nftAddress
+    });
+    const listing = listings.find(
+      (l) => l.orderHash.toLowerCase() === options.orderHash.toLowerCase()
+    );
+    if (!listing) {
+      exitWithError(`Listing with order hash ${options.orderHash} not found or no longer active`);
+    }
+    const prepared = await bazaarClient.prepareFulfillListing(listing, buyerAddress);
+    const result = {
+      approvals: prepared.approvals.map(
+        (a) => encodeTransaction(
+          { to: a.to, functionName: a.functionName, args: a.args, abi: a.abi, value: a.value },
+          readOnlyOptions.chainId
+        )
+      ),
+      fulfillment: encodeTransaction(
+        {
+          to: prepared.fulfillment.to,
+          functionName: prepared.fulfillment.functionName,
+          args: prepared.fulfillment.args,
+          abi: prepared.fulfillment.abi,
+          value: prepared.fulfillment.value
+        },
+        readOnlyOptions.chainId
+      )
+    };
+    console.log(JSON.stringify(result, null, 2));
+  } catch (error) {
+    exitWithError(
+      `Failed to encode buy listing: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+async function executeAcceptOffer(options) {
+  if (options.encodeOnly) {
+    await executeEncodeOnly6(options);
+    return;
+  }
+  const commonOptions = parseCommonOptions(
+    {
+      privateKey: options.privateKey,
+      chainId: options.chainId,
+      rpcUrl: options.rpcUrl
+    },
+    true
+  );
+  const account = privateKeyToAccount(commonOptions.privateKey);
+  const bazaarClient = new BazaarClient({
+    chainId: commonOptions.chainId,
+    rpcUrl: commonOptions.rpcUrl
+  });
+  try {
+    console.log(chalk4.blue("Fetching offers..."));
+    const offers = await bazaarClient.getCollectionOffers({
+      nftAddress: options.nftAddress
+    });
+    const offer = offers.find(
+      (o) => o.orderHash.toLowerCase() === options.orderHash.toLowerCase()
+    );
+    if (!offer) {
+      exitWithError(`Offer with order hash ${options.orderHash} not found or no longer active`);
+    }
+    console.log(chalk4.blue("Preparing fulfillment..."));
+    const prepared = await bazaarClient.prepareFulfillCollectionOffer(
+      offer,
+      options.tokenId,
+      account.address
+    );
+    const rpcUrls = getChainRpcUrls({
+      chainId: commonOptions.chainId,
+      rpcUrl: commonOptions.rpcUrl
+    });
+    const walletClient = createWalletClient({
+      account,
+      transport: http(rpcUrls[0])
+    });
+    for (const approval of prepared.approvals) {
+      console.log(chalk4.blue("Sending approval transaction..."));
+      const calldata2 = encodeFunctionData({
+        abi: approval.abi,
+        functionName: approval.functionName,
+        args: approval.args
+      });
+      const approvalHash = await walletClient.sendTransaction({
+        to: approval.to,
+        data: calldata2,
+        chain: null,
+        value: approval.value
+      });
+      console.log(chalk4.green(`Approval tx: ${approvalHash}`));
+    }
+    console.log(chalk4.blue("Sending fulfillment transaction..."));
+    const calldata = encodeFunctionData({
+      abi: prepared.fulfillment.abi,
+      functionName: prepared.fulfillment.functionName,
+      args: prepared.fulfillment.args
+    });
+    const hash = await walletClient.sendTransaction({
+      to: prepared.fulfillment.to,
+      data: calldata,
+      chain: null,
+      value: prepared.fulfillment.value
+    });
+    console.log(
+      chalk4.green(
+        `Offer accepted successfully!
+  Transaction: ${hash}
+  NFT: ${options.nftAddress} #${options.tokenId}
+  Price: ${offer.price} ${offer.currency.toUpperCase()}`
+      )
+    );
+  } catch (error) {
+    exitWithError(
+      `Failed to accept offer: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+async function executeEncodeOnly6(options) {
+  if (!options.seller) {
+    exitWithError("--seller is required when using --encode-only without --private-key");
+  }
+  const readOnlyOptions = parseReadOnlyOptions({
+    chainId: options.chainId,
+    rpcUrl: options.rpcUrl
+  });
+  const sellerAddress = options.seller;
+  const bazaarClient = new BazaarClient({
+    chainId: readOnlyOptions.chainId,
+    rpcUrl: readOnlyOptions.rpcUrl
+  });
+  try {
+    const offers = await bazaarClient.getCollectionOffers({
+      nftAddress: options.nftAddress
+    });
+    const offer = offers.find(
+      (o) => o.orderHash.toLowerCase() === options.orderHash.toLowerCase()
+    );
+    if (!offer) {
+      exitWithError(`Offer with order hash ${options.orderHash} not found or no longer active`);
+    }
+    const prepared = await bazaarClient.prepareFulfillCollectionOffer(
+      offer,
+      options.tokenId,
+      sellerAddress
+    );
+    const result = {
+      approvals: prepared.approvals.map(
+        (a) => encodeTransaction(
+          { to: a.to, functionName: a.functionName, args: a.args, abi: a.abi, value: a.value },
+          readOnlyOptions.chainId
+        )
+      ),
+      fulfillment: encodeTransaction(
+        {
+          to: prepared.fulfillment.to,
+          functionName: prepared.fulfillment.functionName,
+          args: prepared.fulfillment.args,
+          abi: prepared.fulfillment.abi,
+          value: prepared.fulfillment.value
+        },
+        readOnlyOptions.chainId
+      )
+    };
+    console.log(JSON.stringify(result, null, 2));
+  } catch (error) {
+    exitWithError(
+      `Failed to encode accept offer: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+async function executeOwnedNfts(options) {
+  const readOnlyOptions = parseReadOnlyOptions({
+    chainId: options.chainId,
+    rpcUrl: options.rpcUrl
+  });
+  const bazaarClient = new BazaarClient({
+    chainId: readOnlyOptions.chainId,
+    rpcUrl: readOnlyOptions.rpcUrl
+  });
+  const startTokenId = options.startTokenId ? BigInt(options.startTokenId) : void 0;
+  const endTokenId = options.endTokenId ? BigInt(options.endTokenId) : void 0;
+  try {
+    const tokenIds = await bazaarClient.getOwnedTokens({
+      nftAddress: options.nftAddress,
+      ownerAddress: options.owner,
+      startTokenId,
+      endTokenId
+    });
+    if (options.json) {
+      const output = {
+        nftAddress: options.nftAddress,
+        owner: options.owner,
+        tokenIds: tokenIds.map((id) => id.toString()),
+        count: tokenIds.length
+      };
+      console.log(JSON.stringify(output, null, 2));
+      return;
+    }
+    if (tokenIds.length === 0) {
+      console.log(chalk4.yellow("No owned tokens found in the specified range"));
+      return;
+    }
+    console.log(chalk4.white.bold(`
+Owned Tokens (${tokenIds.length}):
+`));
+    console.log(`  ${chalk4.cyan("Collection:")} ${options.nftAddress}`);
+    console.log(`  ${chalk4.cyan("Owner:")} ${options.owner}`);
+    console.log(`  ${chalk4.cyan("Token IDs:")} ${tokenIds.map((id) => id.toString()).join(", ")}`);
+    console.log();
+  } catch (error) {
+    exitWithError(
+      `Failed to fetch owned tokens: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+
+// src/commands/bazaar/index.ts
+var chainIdOption = [
+  "--chain-id <id>",
+  "Chain ID. Can also be set via NET_CHAIN_ID env var",
+  (value) => parseInt(value, 10)
+];
+var rpcUrlOption = [
+  "--rpc-url <url>",
+  "Custom RPC URL. Can also be set via NET_RPC_URL env var"
+];
+var privateKeyOption = [
+  "--private-key <key>",
+  "Private key (0x-prefixed hex). Can also be set via NET_PRIVATE_KEY env var"
+];
+function registerBazaarCommand(program2) {
+  const bazaarCommand = program2.command("bazaar").description("Bazaar NFT trading operations");
+  const listListingsCommand = new Command("list-listings").description("List active NFT listings").option("--nft-address <address>", "NFT contract address (optional for cross-collection)").option(...chainIdOption).option(...rpcUrlOption).option("--json", "Output in JSON format").action(async (options) => {
+    await executeListListings({
+      nftAddress: options.nftAddress,
+      chainId: options.chainId,
+      rpcUrl: options.rpcUrl,
+      json: options.json
+    });
+  });
+  const listOffersCommand = new Command("list-offers").description("List active collection offers").requiredOption("--nft-address <address>", "NFT contract address").option(...chainIdOption).option(...rpcUrlOption).option("--json", "Output in JSON format").action(async (options) => {
+    await executeListOffers({
+      nftAddress: options.nftAddress,
+      chainId: options.chainId,
+      rpcUrl: options.rpcUrl,
+      json: options.json
+    });
+  });
+  const listSalesCommand = new Command("list-sales").description("List recent sales").requiredOption("--nft-address <address>", "NFT contract address").option(...chainIdOption).option(...rpcUrlOption).option("--json", "Output in JSON format").action(async (options) => {
+    await executeListSales({
+      nftAddress: options.nftAddress,
+      chainId: options.chainId,
+      rpcUrl: options.rpcUrl,
+      json: options.json
+    });
+  });
+  const createListingCommand = new Command("create-listing").description("Create an NFT listing (with --private-key: full flow; without: output EIP-712 data)").requiredOption("--nft-address <address>", "NFT contract address").requiredOption("--token-id <id>", "Token ID to list").requiredOption("--price <eth>", "Price in ETH (e.g., 0.1)").option("--target-fulfiller <address>", "Make a private listing for this address").option("--offerer <address>", "Offerer address (required without --private-key)").option(...privateKeyOption).option(...chainIdOption).option(...rpcUrlOption).action(async (options) => {
+    await executeCreateListing({
+      nftAddress: options.nftAddress,
+      tokenId: options.tokenId,
+      price: options.price,
+      targetFulfiller: options.targetFulfiller,
+      offerer: options.offerer,
+      privateKey: options.privateKey,
+      chainId: options.chainId,
+      rpcUrl: options.rpcUrl
+    });
+  });
+  const createOfferCommand = new Command("create-offer").description("Create a collection offer (with --private-key: full flow; without: output EIP-712 data)").requiredOption("--nft-address <address>", "NFT contract address").requiredOption("--price <eth>", "Offer price in ETH (e.g., 0.1)").option("--offerer <address>", "Offerer address (required without --private-key)").option(...privateKeyOption).option(...chainIdOption).option(...rpcUrlOption).action(async (options) => {
+    await executeCreateOffer({
+      nftAddress: options.nftAddress,
+      price: options.price,
+      offerer: options.offerer,
+      privateKey: options.privateKey,
+      chainId: options.chainId,
+      rpcUrl: options.rpcUrl
+    });
+  });
+  const submitListingCommand = new Command("submit-listing").description("Submit a signed listing (follow-up to create-listing without --private-key)").requiredOption("--order-data <path>", "Path to order JSON file from create-listing output").requiredOption("--signature <sig>", "EIP-712 signature (0x-prefixed)").option(...privateKeyOption).option(...chainIdOption).option(...rpcUrlOption).option("--encode-only", "Output transaction data as JSON instead of executing").action(async (options) => {
+    await executeSubmitListing({
+      orderData: options.orderData,
+      signature: options.signature,
+      privateKey: options.privateKey,
+      chainId: options.chainId,
+      rpcUrl: options.rpcUrl,
+      encodeOnly: options.encodeOnly
+    });
+  });
+  const submitOfferCommand = new Command("submit-offer").description("Submit a signed offer (follow-up to create-offer without --private-key)").requiredOption("--order-data <path>", "Path to order JSON file from create-offer output").requiredOption("--signature <sig>", "EIP-712 signature (0x-prefixed)").option(...privateKeyOption).option(...chainIdOption).option(...rpcUrlOption).option("--encode-only", "Output transaction data as JSON instead of executing").action(async (options) => {
+    await executeSubmitOffer({
+      orderData: options.orderData,
+      signature: options.signature,
+      privateKey: options.privateKey,
+      chainId: options.chainId,
+      rpcUrl: options.rpcUrl,
+      encodeOnly: options.encodeOnly
+    });
+  });
+  const buyListingCommand = new Command("buy-listing").description("Buy an NFT listing").requiredOption("--order-hash <hash>", "Order hash of the listing to buy").requiredOption("--nft-address <address>", "NFT contract address").option("--buyer <address>", "Buyer address (required with --encode-only)").option(...privateKeyOption).option(...chainIdOption).option(...rpcUrlOption).option("--encode-only", "Output transaction data as JSON instead of executing").action(async (options) => {
+    await executeBuyListing({
+      orderHash: options.orderHash,
+      nftAddress: options.nftAddress,
+      buyer: options.buyer,
+      privateKey: options.privateKey,
+      chainId: options.chainId,
+      rpcUrl: options.rpcUrl,
+      encodeOnly: options.encodeOnly
+    });
+  });
+  const acceptOfferCommand = new Command("accept-offer").description("Accept a collection offer by selling your NFT").requiredOption("--order-hash <hash>", "Order hash of the offer to accept").requiredOption("--nft-address <address>", "NFT contract address").requiredOption("--token-id <id>", "Token ID to sell").option("--seller <address>", "Seller address (required with --encode-only)").option(...privateKeyOption).option(...chainIdOption).option(...rpcUrlOption).option("--encode-only", "Output transaction data as JSON instead of executing").action(async (options) => {
+    await executeAcceptOffer({
+      orderHash: options.orderHash,
+      nftAddress: options.nftAddress,
+      tokenId: options.tokenId,
+      seller: options.seller,
+      privateKey: options.privateKey,
+      chainId: options.chainId,
+      rpcUrl: options.rpcUrl,
+      encodeOnly: options.encodeOnly
+    });
+  });
+  const ownedNftsCommand = new Command("owned-nfts").description("List NFTs owned by an address").requiredOption("--nft-address <address>", "NFT contract address").requiredOption("--owner <address>", "Owner address to check").option(...chainIdOption).option(...rpcUrlOption).option("--json", "Output in JSON format").option("--start-token-id <id>", "Start of token ID range (default: 0)").option("--end-token-id <id>", "End of token ID range (default: 10000)").action(async (options) => {
+    await executeOwnedNfts({
+      nftAddress: options.nftAddress,
+      owner: options.owner,
+      chainId: options.chainId,
+      rpcUrl: options.rpcUrl,
+      json: options.json,
+      startTokenId: options.startTokenId,
+      endTokenId: options.endTokenId
+    });
+  });
+  bazaarCommand.addCommand(listListingsCommand);
+  bazaarCommand.addCommand(listOffersCommand);
+  bazaarCommand.addCommand(listSalesCommand);
+  bazaarCommand.addCommand(createListingCommand);
+  bazaarCommand.addCommand(createOfferCommand);
+  bazaarCommand.addCommand(submitListingCommand);
+  bazaarCommand.addCommand(submitOfferCommand);
+  bazaarCommand.addCommand(buyListingCommand);
+  bazaarCommand.addCommand(acceptOfferCommand);
+  bazaarCommand.addCommand(ownedNftsCommand);
+}
+
 // src/cli/index.ts
 var proxyUrl = process.env.https_proxy || process.env.HTTPS_PROXY;
 if (proxyUrl) {
@@ -2951,6 +3991,7 @@ registerChainsCommand(program);
 registerInfoCommand(program);
 registerTokenCommand(program);
 registerProfileCommand(program);
+registerBazaarCommand(program);
 program.parse();
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map