@net-protocol/cli 0.1.12 → 0.1.14

package/dist/cli/index.mjs

@@ -4,19 +4,23 @@ import 'dotenv/config';
 import { Command } from 'commander';
 import { createRequire } from 'module';
 import chalk4 from 'chalk';
-import * as fs2 from 'fs';
+import * as fs4 from 'fs';
 import { readFileSync } from 'fs';
 import { StorageClient, detectFileTypeFromBase64, base64ToDataUri, shouldSuggestXmlStorage, getStorageKeyBytes, encodeStorageKeyForUrl, chunkDataForStorage, CHUNKED_STORAGE_CONTRACT, STORAGE_CONTRACT as STORAGE_CONTRACT$1 } from '@net-protocol/storage';
 import { stringToHex, createWalletClient, http, hexToString, parseEther, encodeFunctionData, publicActions, defineChain } from 'viem';
 import { privateKeyToAccount } from 'viem/accounts';
-import { getNetContract, getChainName, getPublicClient, getChainRpcUrls, NetClient, toBytes32 } from '@net-protocol/core';
+import { getNetContract, getChainName, getPublicClient, getChainRpcUrls, NetClient, toBytes32, NULL_ADDRESS } from '@net-protocol/core';
 import { createRelayX402Client, createRelaySession, checkBackendWalletBalance, fundBackendWallet, batchTransactions, submitTransactionsViaRelay, waitForConfirmations, retryFailedTransactions as retryFailedTransactions$1 } from '@net-protocol/relay';
+import { FeedRegistryClient, FeedClient } from '@net-protocol/feeds';
 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, getProfileMetadataStorageArgs, isValidBio, isValidTokenAddress } from '@net-protocol/profiles';
 import { base } from 'viem/chains';
 import * as path from 'path';
 import { BazaarClient } from '@net-protocol/bazaar';
+import * as os from 'os';
+import * as readline from 'readline';
 
+var DEFAULT_CHAIN_ID = 8453;
 function getRequiredChainId(optionValue) {
   const chainId = optionValue || (process.env.NET_CHAIN_ID ? parseInt(process.env.NET_CHAIN_ID, 10) : void 0);
   if (!chainId) {
@@ -29,9 +33,22 @@ function getRequiredChainId(optionValue) {
   }
   return chainId;
 }
+function getChainIdWithDefault(optionValue) {
+  if (optionValue) {
+    return optionValue;
+  }
+  const envChainId = process.env.BOTCHAN_CHAIN_ID || process.env.NET_CHAIN_ID;
+  if (envChainId) {
+    return parseInt(envChainId, 10);
+  }
+  return DEFAULT_CHAIN_ID;
+}
 function getRpcUrl(optionValue) {
   return optionValue || process.env.NET_RPC_URL;
 }
+function getRpcUrlWithBotchanFallback(optionValue) {
+  return optionValue || process.env.BOTCHAN_RPC_URL || process.env.NET_RPC_URL;
+}
 function parseCommonOptions(options, supportsEncodeOnly = false) {
   const privateKey = options.privateKey || process.env.NET_PRIVATE_KEY || process.env.PRIVATE_KEY;
   if (!privateKey) {
@@ -70,6 +87,44 @@ function parseReadOnlyOptions(options) {
     rpcUrl: getRpcUrl(options.rpcUrl)
   };
 }
+function parseReadOnlyOptionsWithDefault(options) {
+  return {
+    chainId: getChainIdWithDefault(options.chainId),
+    rpcUrl: getRpcUrlWithBotchanFallback(options.rpcUrl)
+  };
+}
+function parseCommonOptionsWithDefault(options, supportsEncodeOnly = false) {
+  const privateKey = options.privateKey || process.env.BOTCHAN_PRIVATE_KEY || process.env.NET_PRIVATE_KEY || process.env.PRIVATE_KEY;
+  if (!privateKey) {
+    const encodeOnlyHint = supportsEncodeOnly ? ", or use --encode-only to output transaction data without submitting" : "";
+    console.error(
+      chalk4.red(
+        `Error: Private key is required. Provide via --private-key flag or NET_PRIVATE_KEY/BOTCHAN_PRIVATE_KEY environment variable${encodeOnlyHint}`
+      )
+    );
+    process.exit(1);
+  }
+  if (!privateKey.startsWith("0x") || privateKey.length !== 66) {
+    console.error(
+      chalk4.red(
+        "Error: Invalid private key format (must be 0x-prefixed, 66 characters)"
+      )
+    );
+    process.exit(1);
+  }
+  if (options.privateKey) {
+    console.warn(
+      chalk4.yellow(
+        "Warning: Private key provided via command line. Consider using NET_PRIVATE_KEY environment variable instead."
+      )
+    );
+  }
+  return {
+    privateKey,
+    chainId: getChainIdWithDefault(options.chainId),
+    rpcUrl: getRpcUrlWithBotchanFallback(options.rpcUrl)
+  };
+}
 async function checkNormalStorageExists(params) {
   const { storageClient, storageKey, operatorAddress, expectedContent } = params;
   const existing = await storageClient.get({
@@ -1194,7 +1249,7 @@ async function encodeStorageUpload(options) {
   } else {
     operatorAddress = "0x0000000000000000000000000000000000000000";
   }
-  const fileContent = fs2.readFileSync(options.filePath, "utf-8");
+  const fileContent = fs4.readFileSync(options.filePath, "utf-8");
   const fileSize = Buffer.byteLength(fileContent, "utf-8");
   const client = new StorageClient({
     chainId: readOnlyOptions.chainId
@@ -1478,8 +1533,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: privateKeyToAccount17 } = await import('viem/accounts');
-      const userAccount = privateKeyToAccount17(commonOptions.privateKey);
+      const { privateKeyToAccount: privateKeyToAccount24 } = await import('viem/accounts');
+      const userAccount = privateKeyToAccount24(commonOptions.privateKey);
       const storageUrl = generateStorageUrl(
         userAccount.address,
         commonOptions.chainId,
@@ -1549,6 +1604,18 @@ function registerStorageCommand(program2) {
   storageCommand.addCommand(uploadRelayCommand);
   storageCommand.addCommand(readCommand);
 }
+function createFeedClient(options) {
+  return new FeedClient({
+    chainId: options.chainId,
+    overrides: options.rpcUrl ? { rpcUrls: [options.rpcUrl] } : void 0
+  });
+}
+function createFeedRegistryClient(options) {
+  return new FeedRegistryClient({
+    chainId: options.chainId,
+    overrides: options.rpcUrl ? { rpcUrls: [options.rpcUrl] } : void 0
+  });
+}
 function createNetClient(options) {
   return new NetClient({
     chainId: options.chainId,
@@ -2755,10 +2822,10 @@ async function executeProfileSetCanvas(options) {
   let canvasContent;
   if (options.file) {
     const filePath = path.resolve(options.file);
-    if (!fs2.existsSync(filePath)) {
+    if (!fs4.existsSync(filePath)) {
       exitWithError(`File not found: ${filePath}`);
     }
-    const buffer = fs2.readFileSync(filePath);
+    const buffer = fs4.readFileSync(filePath);
     if (buffer.length > MAX_CANVAS_SIZE) {
       exitWithError(
         `File too large: ${buffer.length} bytes exceeds maximum of ${MAX_CANVAS_SIZE} bytes (60KB).`
@@ -2933,12 +3000,12 @@ async function executeProfileGetCanvas(options) {
         if (!path.extname(outputPath)) {
           finalPath = outputPath + getExtensionFromMimeType(mimeType);
         }
-        fs2.writeFileSync(finalPath, buffer);
+        fs4.writeFileSync(finalPath, buffer);
         console.log(
           chalk4.green(`Canvas written to: ${finalPath} (${buffer.length} bytes)`)
         );
       } else {
-        fs2.writeFileSync(outputPath, canvasContent, "utf-8");
+        fs4.writeFileSync(outputPath, canvasContent, "utf-8");
         console.log(
           chalk4.green(
             `Canvas written to: ${outputPath} (${canvasContent.length} bytes)`
@@ -4025,133 +4092,2293 @@ Owned Tokens (${tokenIds.length}):
     );
   }
 }
-
-// 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
-    });
+async function executeListErc20Listings(options) {
+  const readOnlyOptions = parseReadOnlyOptions({
+    chainId: options.chainId,
+    rpcUrl: options.rpcUrl
   });
-  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 bazaarClient = new BazaarClient({
+    chainId: readOnlyOptions.chainId,
+    rpcUrl: readOnlyOptions.rpcUrl
   });
-  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
+  try {
+    const listings = await bazaarClient.getErc20Listings({
+      tokenAddress: options.tokenAddress
     });
+    if (options.json) {
+      const output = listings.map((l) => ({
+        orderHash: l.orderHash,
+        maker: l.maker,
+        tokenAddress: l.tokenAddress,
+        tokenAmount: l.tokenAmount.toString(),
+        price: l.price,
+        priceWei: l.priceWei.toString(),
+        pricePerToken: l.pricePerToken,
+        pricePerTokenWei: l.pricePerTokenWei.toString(),
+        currency: l.currency,
+        expirationDate: l.expirationDate,
+        orderStatus: l.orderStatus
+      }));
+      console.log(JSON.stringify(output, null, 2));
+      return;
+    }
+    if (listings.length === 0) {
+      console.log(chalk4.yellow("No active ERC-20 listings found"));
+      return;
+    }
+    console.log(chalk4.white.bold(`
+ERC-20 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("Token:")} ${listing.tokenAddress}`);
+      console.log(`  ${chalk4.cyan("Amount:")} ${listing.tokenAmount.toString()}`);
+      console.log(`  ${chalk4.cyan("Price:")} ${formatEthPrice(listing.price)} ${listing.currency.toUpperCase()}`);
+      console.log(`  ${chalk4.cyan("Price/Token:")} ${formatEthPrice(listing.pricePerToken)} ${listing.currency.toUpperCase()}`);
+      console.log(`  ${chalk4.cyan("Expires:")} ${expiry}`);
+      console.log();
+    }
+  } catch (error) {
+    exitWithError(
+      `Failed to fetch ERC-20 listings: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+async function executeListErc20Offers(options) {
+  const readOnlyOptions = parseReadOnlyOptions({
+    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 bazaarClient = new BazaarClient({
+    chainId: readOnlyOptions.chainId,
+    rpcUrl: readOnlyOptions.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
+  try {
+    const offers = await bazaarClient.getErc20Offers({
+      tokenAddress: options.tokenAddress
     });
+    if (options.json) {
+      const output = offers.map((o) => ({
+        orderHash: o.orderHash,
+        maker: o.maker,
+        tokenAddress: o.tokenAddress,
+        tokenAmount: o.tokenAmount.toString(),
+        price: o.price,
+        priceWei: o.priceWei.toString(),
+        pricePerToken: o.pricePerToken,
+        pricePerTokenWei: o.pricePerTokenWei.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 ERC-20 offers found"));
+      return;
+    }
+    console.log(chalk4.white.bold(`
+ERC-20 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("Token:")} ${offer.tokenAddress}`);
+      console.log(`  ${chalk4.cyan("Amount:")} ${offer.tokenAmount.toString()}`);
+      console.log(`  ${chalk4.cyan("Price:")} ${formatEthPrice(offer.price)} ${offer.currency.toUpperCase()}`);
+      console.log(`  ${chalk4.cyan("Price/Token:")} ${formatEthPrice(offer.pricePerToken)} ${offer.currency.toUpperCase()}`);
+      console.log(`  ${chalk4.cyan("Expires:")} ${expiry}`);
+      console.log();
+    }
+  } catch (error) {
+    exitWithError(
+      `Failed to fetch ERC-20 offers: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+async function executeCreateErc20Listing(options) {
+  const hasPrivateKey = !!(options.privateKey || process.env.NET_PRIVATE_KEY || process.env.PRIVATE_KEY);
+  if (!hasPrivateKey) {
+    await executeKeylessMode3(options);
+    return;
+  }
+  const commonOptions = parseCommonOptions({
+    privateKey: options.privateKey,
+    chainId: options.chainId,
+    rpcUrl: options.rpcUrl
   });
-  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 account = privateKeyToAccount(commonOptions.privateKey);
+  const bazaarClient = new BazaarClient({
+    chainId: commonOptions.chainId,
+    rpcUrl: commonOptions.rpcUrl
   });
-  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 priceWei = parseEther(options.price);
+  const tokenAmount = BigInt(options.tokenAmount);
+  try {
+    console.log(chalk4.blue("Preparing ERC-20 listing..."));
+    const prepared = await bazaarClient.prepareCreateErc20Listing({
+      tokenAddress: options.tokenAddress,
+      tokenAmount,
+      priceWei,
+      offerer: account.address
     });
-  });
-  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 rpcUrls = getChainRpcUrls({
+      chainId: commonOptions.chainId,
+      rpcUrl: commonOptions.rpcUrl
     });
-  });
-  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
+    const walletClient = createWalletClient({
+      account,
+      transport: http(rpcUrls[0])
     });
-  });
-  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);
+    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 ERC-20 listing..."));
+    const submitTx = bazaarClient.prepareSubmitErc20Listing(
+      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(
+        `ERC-20 listing created successfully!
+  Transaction: ${hash}
+  Token: ${options.tokenAddress}
+  Amount: ${options.tokenAmount}
+  Price: ${options.price} ETH`
+      )
+    );
+  } catch (error) {
+    exitWithError(
+      `Failed to create ERC-20 listing: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+async function executeKeylessMode3(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);
+  const tokenAmount = BigInt(options.tokenAmount);
+  try {
+    const prepared = await bazaarClient.prepareCreateErc20Listing({
+      tokenAddress: options.tokenAddress,
+      tokenAmount,
+      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, bigintReplacer3, 2));
+  } catch (error) {
+    exitWithError(
+      `Failed to prepare ERC-20 listing: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+function bigintReplacer3(_key, value) {
+  if (typeof value === "bigint") {
+    return value.toString();
+  }
+  return value;
+}
+async function executeCreateErc20Offer(options) {
+  const hasPrivateKey = !!(options.privateKey || process.env.NET_PRIVATE_KEY || process.env.PRIVATE_KEY);
+  if (!hasPrivateKey) {
+    await executeKeylessMode4(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);
+  const tokenAmount = BigInt(options.tokenAmount);
+  try {
+    console.log(chalk4.blue("Preparing ERC-20 offer..."));
+    const prepared = await bazaarClient.prepareCreateErc20Offer({
+      tokenAddress: options.tokenAddress,
+      tokenAmount,
+      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 ERC-20 offer..."));
+    const submitTx = bazaarClient.prepareSubmitErc20Offer(
+      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(
+        `ERC-20 offer created successfully!
+  Transaction: ${hash}
+  Token: ${options.tokenAddress}
+  Amount: ${options.tokenAmount}
+  Price: ${options.price} ETH`
+      )
+    );
+  } catch (error) {
+    exitWithError(
+      `Failed to create ERC-20 offer: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+async function executeKeylessMode4(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);
+  const tokenAmount = BigInt(options.tokenAmount);
+  try {
+    const prepared = await bazaarClient.prepareCreateErc20Offer({
+      tokenAddress: options.tokenAddress,
+      tokenAmount,
+      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, bigintReplacer4, 2));
+  } catch (error) {
+    exitWithError(
+      `Failed to prepare ERC-20 offer: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+function bigintReplacer4(_key, value) {
+  if (typeof value === "bigint") {
+    return value.toString();
+  }
+  return value;
+}
+async function executeSubmitErc20Listing(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 executeEncodeOnly7(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.prepareSubmitErc20Listing(
+      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 ERC-20 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(`ERC-20 listing submitted successfully!
+  Transaction: ${hash}`));
+  } catch (error) {
+    exitWithError(
+      `Failed to submit ERC-20 listing: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+async function executeEncodeOnly7(options, orderData) {
+  const readOnlyOptions = parseReadOnlyOptions({
+    chainId: options.chainId,
+    rpcUrl: options.rpcUrl
+  });
+  const bazaarClient = new BazaarClient({
+    chainId: readOnlyOptions.chainId,
+    rpcUrl: readOnlyOptions.rpcUrl
+  });
+  const submitTx = bazaarClient.prepareSubmitErc20Listing(
+    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 executeSubmitErc20Offer(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 executeEncodeOnly8(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.prepareSubmitErc20Offer(
+      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 ERC-20 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(`ERC-20 offer submitted successfully!
+  Transaction: ${hash}`));
+  } catch (error) {
+    exitWithError(
+      `Failed to submit ERC-20 offer: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+async function executeEncodeOnly8(options, orderData) {
+  const readOnlyOptions = parseReadOnlyOptions({
+    chainId: options.chainId,
+    rpcUrl: options.rpcUrl
+  });
+  const bazaarClient = new BazaarClient({
+    chainId: readOnlyOptions.chainId,
+    rpcUrl: readOnlyOptions.rpcUrl
+  });
+  const submitTx = bazaarClient.prepareSubmitErc20Offer(
+    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 executeBuyErc20Listing(options) {
+  if (options.encodeOnly) {
+    await executeEncodeOnly9(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 ERC-20 listing..."));
+    const listings = await bazaarClient.getErc20Listings({
+      tokenAddress: options.tokenAddress
+    });
+    const listing = listings.find(
+      (l) => l.orderHash.toLowerCase() === options.orderHash.toLowerCase()
+    );
+    if (!listing) {
+      exitWithError(`ERC-20 listing with order hash ${options.orderHash} not found or no longer active`);
+    }
+    console.log(chalk4.blue("Preparing fulfillment..."));
+    const prepared = await bazaarClient.prepareFulfillErc20Listing(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(
+        `ERC-20 listing fulfilled successfully!
+  Transaction: ${hash}
+  Token: ${listing.tokenAddress}
+  Amount: ${listing.tokenAmount.toString()}
+  Price: ${listing.price} ${listing.currency.toUpperCase()}`
+      )
+    );
+  } catch (error) {
+    exitWithError(
+      `Failed to buy ERC-20 listing: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+async function executeEncodeOnly9(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.getErc20Listings({
+      tokenAddress: options.tokenAddress
+    });
+    const listing = listings.find(
+      (l) => l.orderHash.toLowerCase() === options.orderHash.toLowerCase()
+    );
+    if (!listing) {
+      exitWithError(`ERC-20 listing with order hash ${options.orderHash} not found or no longer active`);
+    }
+    const prepared = await bazaarClient.prepareFulfillErc20Listing(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 ERC-20 listing: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+async function executeAcceptErc20Offer(options) {
+  if (options.encodeOnly) {
+    await executeEncodeOnly10(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 ERC-20 offers..."));
+    const offers = await bazaarClient.getErc20Offers({
+      tokenAddress: options.tokenAddress
+    });
+    const offer = offers.find(
+      (o) => o.orderHash.toLowerCase() === options.orderHash.toLowerCase()
+    );
+    if (!offer) {
+      exitWithError(`ERC-20 offer with order hash ${options.orderHash} not found or no longer active`);
+    }
+    console.log(chalk4.blue("Preparing fulfillment..."));
+    const prepared = await bazaarClient.prepareFulfillErc20Offer(
+      offer,
+      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(
+        `ERC-20 offer accepted successfully!
+  Transaction: ${hash}
+  Token: ${offer.tokenAddress}
+  Amount: ${offer.tokenAmount.toString()}
+  Price: ${offer.price} ${offer.currency.toUpperCase()}`
+      )
+    );
+  } catch (error) {
+    exitWithError(
+      `Failed to accept ERC-20 offer: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+async function executeEncodeOnly10(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.getErc20Offers({
+      tokenAddress: options.tokenAddress
+    });
+    const offer = offers.find(
+      (o) => o.orderHash.toLowerCase() === options.orderHash.toLowerCase()
+    );
+    if (!offer) {
+      exitWithError(`ERC-20 offer with order hash ${options.orderHash} not found or no longer active`);
+    }
+    const prepared = await bazaarClient.prepareFulfillErc20Offer(
+      offer,
+      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 ERC-20 offer: ${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
+    });
+  });
+  const listErc20ListingsCommand = new Command("list-erc20-listings").description("List active ERC-20 token listings").requiredOption("--token-address <address>", "ERC-20 token contract address").option(...chainIdOption).option(...rpcUrlOption).option("--json", "Output in JSON format").action(async (options) => {
+    await executeListErc20Listings({
+      tokenAddress: options.tokenAddress,
+      chainId: options.chainId,
+      rpcUrl: options.rpcUrl,
+      json: options.json
+    });
+  });
+  const listErc20OffersCommand = new Command("list-erc20-offers").description("List active ERC-20 token offers").requiredOption("--token-address <address>", "ERC-20 token contract address").option(...chainIdOption).option(...rpcUrlOption).option("--json", "Output in JSON format").action(async (options) => {
+    await executeListErc20Offers({
+      tokenAddress: options.tokenAddress,
+      chainId: options.chainId,
+      rpcUrl: options.rpcUrl,
+      json: options.json
+    });
+  });
+  const createErc20ListingCommand = new Command("create-erc20-listing").description("Create an ERC-20 token listing (with --private-key: full flow; without: output EIP-712 data)").requiredOption("--token-address <address>", "ERC-20 token contract address").requiredOption("--token-amount <amount>", "Token amount in raw units (bigint string)").requiredOption("--price <eth>", "Total price in ETH for the token amount").option("--offerer <address>", "Offerer address (required without --private-key)").option(...privateKeyOption).option(...chainIdOption).option(...rpcUrlOption).action(async (options) => {
+    await executeCreateErc20Listing({
+      tokenAddress: options.tokenAddress,
+      tokenAmount: options.tokenAmount,
+      price: options.price,
+      offerer: options.offerer,
+      privateKey: options.privateKey,
+      chainId: options.chainId,
+      rpcUrl: options.rpcUrl
+    });
+  });
+  const createErc20OfferCommand = new Command("create-erc20-offer").description("Create an ERC-20 token offer (with --private-key: full flow; without: output EIP-712 data)").requiredOption("--token-address <address>", "ERC-20 token contract address").requiredOption("--token-amount <amount>", "Token amount in raw units (bigint string)").requiredOption("--price <eth>", "Total price in ETH for the token amount").option("--offerer <address>", "Offerer address (required without --private-key)").option(...privateKeyOption).option(...chainIdOption).option(...rpcUrlOption).action(async (options) => {
+    await executeCreateErc20Offer({
+      tokenAddress: options.tokenAddress,
+      tokenAmount: options.tokenAmount,
+      price: options.price,
+      offerer: options.offerer,
+      privateKey: options.privateKey,
+      chainId: options.chainId,
+      rpcUrl: options.rpcUrl
+    });
+  });
+  const submitErc20ListingCommand = new Command("submit-erc20-listing").description("Submit a signed ERC-20 listing (follow-up to create-erc20-listing without --private-key)").requiredOption("--order-data <path>", "Path to order JSON file from create-erc20-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 executeSubmitErc20Listing({
+      orderData: options.orderData,
+      signature: options.signature,
+      privateKey: options.privateKey,
+      chainId: options.chainId,
+      rpcUrl: options.rpcUrl,
+      encodeOnly: options.encodeOnly
+    });
+  });
+  const submitErc20OfferCommand = new Command("submit-erc20-offer").description("Submit a signed ERC-20 offer (follow-up to create-erc20-offer without --private-key)").requiredOption("--order-data <path>", "Path to order JSON file from create-erc20-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 executeSubmitErc20Offer({
+      orderData: options.orderData,
+      signature: options.signature,
+      privateKey: options.privateKey,
+      chainId: options.chainId,
+      rpcUrl: options.rpcUrl,
+      encodeOnly: options.encodeOnly
+    });
+  });
+  const buyErc20ListingCommand = new Command("buy-erc20-listing").description("Buy an ERC-20 token listing").requiredOption("--order-hash <hash>", "Order hash of the listing to buy").requiredOption("--token-address <address>", "ERC-20 token 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 executeBuyErc20Listing({
+      orderHash: options.orderHash,
+      tokenAddress: options.tokenAddress,
+      buyer: options.buyer,
+      privateKey: options.privateKey,
+      chainId: options.chainId,
+      rpcUrl: options.rpcUrl,
+      encodeOnly: options.encodeOnly
+    });
+  });
+  const acceptErc20OfferCommand = new Command("accept-erc20-offer").description("Accept an ERC-20 token offer by selling your tokens").requiredOption("--order-hash <hash>", "Order hash of the offer to accept").requiredOption("--token-address <address>", "ERC-20 token contract address").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 executeAcceptErc20Offer({
+      orderHash: options.orderHash,
+      tokenAddress: options.tokenAddress,
+      seller: options.seller,
+      privateKey: options.privateKey,
+      chainId: options.chainId,
+      rpcUrl: options.rpcUrl,
+      encodeOnly: options.encodeOnly
+    });
+  });
+  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);
+  bazaarCommand.addCommand(listErc20ListingsCommand);
+  bazaarCommand.addCommand(listErc20OffersCommand);
+  bazaarCommand.addCommand(createErc20ListingCommand);
+  bazaarCommand.addCommand(createErc20OfferCommand);
+  bazaarCommand.addCommand(submitErc20ListingCommand);
+  bazaarCommand.addCommand(submitErc20OfferCommand);
+  bazaarCommand.addCommand(buyErc20ListingCommand);
+  bazaarCommand.addCommand(acceptErc20OfferCommand);
+}
+function truncateAddress(address) {
+  if (address.length <= 12) return address;
+  return `${address.slice(0, 6)}...${address.slice(-4)}`;
+}
+function formatTimestamp(timestamp) {
+  return new Date(Number(timestamp) * 1e3).toISOString().replace("T", " ").slice(0, 19);
+}
+function parseTopic(topic) {
+  const commentMatch = topic.match(/^(.+?):comments:/);
+  if (commentMatch) {
+    return { feedName: commentMatch[1], isComment: true };
+  }
+  return { feedName: topic, isComment: false };
+}
+function formatPost(post, index, options = {}) {
+  const { commentCount, showTopic } = options;
+  const timestamp = formatTimestamp(post.timestamp);
+  const lines = [
+    chalk4.cyan(`[${index}]`) + ` ${chalk4.gray(timestamp)}`,
+    `  ${chalk4.white("Sender:")} ${post.sender}`,
+    `  ${chalk4.white("Text:")} ${post.text}`
+  ];
+  if (showTopic && post.topic) {
+    const { feedName, isComment } = parseTopic(post.topic);
+    const prefix = isComment ? "Comment on" : "Feed";
+    lines.push(`  ${chalk4.white(prefix + ":")} ${chalk4.magenta(feedName)}`);
+  }
+  if (commentCount !== void 0) {
+    lines.push(`  ${chalk4.white("Comments:")} ${commentCount}`);
+  }
+  if (post.data && post.data !== "0x") {
+    lines.push(`  ${chalk4.white("Data:")} ${post.data}`);
+  }
+  return lines.join("\n");
+}
+function formatFeed(feed, index) {
+  const timestamp = formatTimestamp(feed.timestamp);
+  const lines = [
+    chalk4.cyan(`[${index}]`) + ` ${chalk4.white(feed.feedName)}`,
+    `    ${chalk4.gray("Registrant:")} ${feed.registrant}`,
+    `    ${chalk4.gray("Registered:")} ${timestamp}`
+  ];
+  return lines.join("\n");
+}
+function formatComment(comment, depth) {
+  const indent = "  ".repeat(depth + 1);
+  const timestamp = formatTimestamp(comment.timestamp);
+  const lines = [
+    `${indent}${chalk4.gray(timestamp)} ${chalk4.blue(truncateAddress(comment.sender))}`,
+    `${indent}${comment.text}`
+  ];
+  return lines.join("\n");
+}
+function postToJson(post, index, commentCount) {
+  const result = {
+    index,
+    sender: post.sender,
+    text: post.text,
+    timestamp: Number(post.timestamp),
+    topic: post.topic
+  };
+  if (commentCount !== void 0) {
+    result.commentCount = commentCount;
+  }
+  if (post.data && post.data !== "0x") {
+    result.data = post.data;
+  }
+  return result;
+}
+function feedToJson(feed, index) {
+  return {
+    index,
+    feedName: feed.feedName,
+    registrant: feed.registrant,
+    timestamp: feed.timestamp
+  };
+}
+function commentToJson(comment, depth) {
+  return {
+    sender: comment.sender,
+    text: comment.text,
+    timestamp: Number(comment.timestamp),
+    depth,
+    data: comment.data !== "0x" ? comment.data : void 0
+  };
+}
+function printJson(data) {
+  console.log(JSON.stringify(data, null, 2));
+}
+
+// src/commands/feed/list.ts
+async function executeFeedList(options) {
+  const readOnlyOptions = parseReadOnlyOptionsWithDefault({
+    chainId: options.chainId,
+    rpcUrl: options.rpcUrl
+  });
+  const client = createFeedRegistryClient(readOnlyOptions);
+  try {
+    const feeds = await client.getRegisteredFeeds({
+      maxFeeds: options.limit ?? 50
+    });
+    if (options.json) {
+      printJson(feeds.map((feed, i) => feedToJson(feed, i)));
+    } else {
+      if (feeds.length === 0) {
+        console.log(chalk4.yellow("No registered feeds found"));
+        return;
+      }
+      console.log(chalk4.white(`Found ${feeds.length} registered feed(s):
+`));
+      feeds.forEach((feed, i) => {
+        console.log(formatFeed(feed, i));
+        if (i < feeds.length - 1) {
+          console.log();
+        }
+      });
+    }
+  } catch (error) {
+    exitWithError(
+      `Failed to fetch feeds: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+function registerFeedListCommand(parent, commandName = "list") {
+  parent.command(commandName).description("List registered feeds").option(
+    "--limit <n>",
+    "Maximum number of feeds to display",
+    (value) => parseInt(value, 10)
+  ).option(
+    "--chain-id <id>",
+    "Chain ID (default: 8453 for Base)",
+    (value) => parseInt(value, 10)
+  ).option("--rpc-url <url>", "Custom RPC URL").option("--json", "Output in JSON format").action(async (options) => {
+    await executeFeedList(options);
+  });
+}
+var MAX_HISTORY_ENTRIES = 100;
+var STATE_DIR = path.join(os.homedir(), ".botchan");
+var STATE_FILE = path.join(STATE_DIR, "state.json");
+function ensureStateDir() {
+  if (!fs4.existsSync(STATE_DIR)) {
+    fs4.mkdirSync(STATE_DIR, { recursive: true });
+  }
+}
+function loadState() {
+  try {
+    if (fs4.existsSync(STATE_FILE)) {
+      const data = fs4.readFileSync(STATE_FILE, "utf-8");
+      return JSON.parse(data);
+    }
+  } catch {
+  }
+  return { feeds: {} };
+}
+function saveState(state) {
+  ensureStateDir();
+  const tempFile = `${STATE_FILE}.tmp`;
+  fs4.writeFileSync(tempFile, JSON.stringify(state, null, 2));
+  fs4.renameSync(tempFile, STATE_FILE);
+}
+function getLastSeenTimestamp(feedName) {
+  const state = loadState();
+  return state.feeds[feedName]?.lastSeenTimestamp ?? null;
+}
+function setLastSeenTimestamp(feedName, timestamp) {
+  const state = loadState();
+  if (!state.feeds[feedName]) {
+    state.feeds[feedName] = { lastSeenTimestamp: timestamp };
+  } else {
+    state.feeds[feedName].lastSeenTimestamp = timestamp;
+  }
+  saveState(state);
+}
+function markFeedSeen(feedName, posts) {
+  if (posts.length === 0) return;
+  const maxTimestamp = posts.reduce(
+    (max, post) => post.timestamp > max ? post.timestamp : max,
+    posts[0].timestamp
+  );
+  setLastSeenTimestamp(feedName, Number(maxTimestamp));
+}
+function getMyAddress() {
+  const state = loadState();
+  return state.myAddress ?? null;
+}
+function setMyAddress(address) {
+  const state = loadState();
+  state.myAddress = address.toLowerCase();
+  saveState(state);
+}
+function clearMyAddress() {
+  const state = loadState();
+  delete state.myAddress;
+  saveState(state);
+}
+function getFullState() {
+  return loadState();
+}
+function resetState() {
+  if (fs4.existsSync(STATE_FILE)) {
+    fs4.unlinkSync(STATE_FILE);
+  }
+}
+function getStateFilePath() {
+  return STATE_FILE;
+}
+function addHistoryEntry(entry) {
+  const state = loadState();
+  const history = state.history ?? [];
+  const newEntry = {
+    ...entry,
+    timestamp: Math.floor(Date.now() / 1e3)
+  };
+  history.unshift(newEntry);
+  if (history.length > MAX_HISTORY_ENTRIES) {
+    history.length = MAX_HISTORY_ENTRIES;
+  }
+  state.history = history;
+  saveState(state);
+}
+function getHistory(limit) {
+  const state = loadState();
+  const history = state.history ?? [];
+  return limit ? history.slice(0, limit) : history;
+}
+function getHistoryByType(type, limit) {
+  const history = getHistory();
+  const filtered = history.filter((entry) => entry.type === type);
+  return limit ? filtered.slice(0, limit) : filtered;
+}
+function clearHistory() {
+  const state = loadState();
+  state.history = [];
+  saveState(state);
+}
+function getHistoryCount() {
+  const state = loadState();
+  return state.history?.length ?? 0;
+}
+function isWalletAddress(feed) {
+  return /^0x[a-fA-F0-9]{40}$/.test(feed);
+}
+function getContacts() {
+  const history = getHistory();
+  const contactMap = /* @__PURE__ */ new Map();
+  for (const entry of history) {
+    if (entry.type === "post" && isWalletAddress(entry.feed)) {
+      const address = entry.feed.toLowerCase();
+      const existing = contactMap.get(address);
+      if (existing) {
+        existing.interactionCount++;
+        if (entry.timestamp > existing.lastInteraction) {
+          existing.lastInteraction = entry.timestamp;
+        }
+        if (entry.timestamp < existing.firstInteraction) {
+          existing.firstInteraction = entry.timestamp;
+        }
+      } else {
+        contactMap.set(address, {
+          address,
+          lastInteraction: entry.timestamp,
+          firstInteraction: entry.timestamp,
+          interactionCount: 1
+        });
+      }
+    }
+  }
+  return Array.from(contactMap.values()).sort(
+    (a, b) => b.lastInteraction - a.lastInteraction
+  );
+}
+function getActiveFeeds() {
+  const history = getHistory();
+  const feedMap = /* @__PURE__ */ new Map();
+  for (const entry of history) {
+    if (isWalletAddress(entry.feed)) continue;
+    if (entry.type === "register") continue;
+    const feedName = entry.feed.toLowerCase();
+    const existing = feedMap.get(feedName);
+    if (existing) {
+      if (entry.type === "post") existing.postCount++;
+      if (entry.type === "comment") existing.commentCount++;
+      if (entry.timestamp > existing.lastActivity) {
+        existing.lastActivity = entry.timestamp;
+      }
+      if (entry.timestamp < existing.firstActivity) {
+        existing.firstActivity = entry.timestamp;
+      }
+    } else {
+      feedMap.set(feedName, {
+        feed: feedName,
+        postCount: entry.type === "post" ? 1 : 0,
+        commentCount: entry.type === "comment" ? 1 : 0,
+        lastActivity: entry.timestamp,
+        firstActivity: entry.timestamp
+      });
+    }
+  }
+  return Array.from(feedMap.values()).sort(
+    (a, b) => b.lastActivity - a.lastActivity
+  );
+}
+
+// src/commands/feed/types.ts
+function normalizeFeedName(feed) {
+  return feed.toLowerCase();
+}
+
+// src/commands/feed/read.ts
+async function executeFeedRead(feed, options) {
+  const normalizedFeed = normalizeFeedName(feed);
+  const readOnlyOptions = parseReadOnlyOptionsWithDefault({
+    chainId: options.chainId,
+    rpcUrl: options.rpcUrl
+  });
+  const client = createFeedClient(readOnlyOptions);
+  const limit = options.limit ?? 20;
+  try {
+    const count = await client.getFeedPostCount(normalizedFeed);
+    if (count === 0) {
+      if (options.json) {
+        printJson([]);
+      } else {
+        console.log(chalk4.yellow(`No posts found in feed "${normalizedFeed}"`));
+      }
+      return;
+    }
+    const fetchLimit = options.sender ? Math.max(limit * 5, 100) : limit;
+    let posts = await client.getFeedPosts({
+      topic: normalizedFeed,
+      maxPosts: fetchLimit
+    });
+    if (options.sender) {
+      const senderLower = options.sender.toLowerCase();
+      posts = posts.filter(
+        (post) => post.sender.toLowerCase() === senderLower
+      );
+      posts = posts.slice(0, limit);
+    }
+    if (options.unseen) {
+      const lastSeen = getLastSeenTimestamp(normalizedFeed);
+      const myAddress = getMyAddress();
+      posts = posts.filter((post) => {
+        const isNew = lastSeen === null || Number(post.timestamp) > lastSeen;
+        const isFromOther = !myAddress || post.sender.toLowerCase() !== myAddress;
+        return isNew && isFromOther;
+      });
+    }
+    if (options.markSeen) {
+      const allPosts = await client.getFeedPosts({
+        topic: normalizedFeed,
+        maxPosts: 1
+        // Just need the latest
+      });
+      if (allPosts.length > 0) {
+        markFeedSeen(normalizedFeed, allPosts);
+      }
+    }
+    const commentCounts = await Promise.all(
+      posts.map((post) => client.getCommentCount(post))
+    );
+    if (options.json) {
+      printJson(
+        posts.map((post, i) => postToJson(post, i, commentCounts[i]))
+      );
+    } else {
+      if (posts.length === 0) {
+        const senderNote2 = options.sender ? ` by ${options.sender}` : "";
+        console.log(chalk4.yellow(`No posts found in feed "${normalizedFeed}"${senderNote2}`));
+        return;
+      }
+      const senderNote = options.sender ? ` by ${options.sender}` : "";
+      console.log(
+        chalk4.white(`Found ${posts.length} post(s) in feed "${normalizedFeed}"${senderNote}:
+`)
+      );
+      posts.forEach((post, i) => {
+        console.log(formatPost(post, i, { commentCount: commentCounts[i] }));
+        if (i < posts.length - 1) {
+          console.log();
+        }
+      });
+    }
+  } catch (error) {
+    exitWithError(
+      `Failed to read feed: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+function registerFeedReadCommand(parent) {
+  parent.command("read <feed>").description("Read posts from a feed").option(
+    "--limit <n>",
+    "Maximum number of posts to display",
+    (value) => parseInt(value, 10)
+  ).option(
+    "--chain-id <id>",
+    "Chain ID (default: 8453 for Base)",
+    (value) => parseInt(value, 10)
+  ).option("--rpc-url <url>", "Custom RPC URL").option("--sender <address>", "Filter posts by sender address").option("--unseen", "Only show posts not yet seen (newer than last --mark-seen)").option("--mark-seen", "Mark the feed as seen up to the latest post").option("--json", "Output in JSON format").action(async (feed, options) => {
+    await executeFeedRead(feed, options);
+  });
+}
+function createWallet(privateKey, chainId, rpcUrl) {
+  const account = privateKeyToAccount(privateKey);
+  const rpcUrls = getChainRpcUrls({
+    chainId,
+    rpcUrl
+  });
+  return createWalletClient({
+    account,
+    transport: http(rpcUrls[0])
+  });
+}
+async function executeTransaction(walletClient, txConfig) {
+  const hash = await walletClient.writeContract({
+    address: txConfig.to,
+    abi: txConfig.abi,
+    functionName: txConfig.functionName,
+    args: txConfig.args,
+    value: txConfig.value,
+    chain: null
+  });
+  return hash;
+}
+
+// src/commands/feed/post.ts
+var MAX_MESSAGE_LENGTH = 4e3;
+async function executeFeedPost(feed, message, options) {
+  const normalizedFeed = normalizeFeedName(feed);
+  if (message.length === 0) {
+    exitWithError("Message cannot be empty");
+  }
+  const fullMessage = options.body ? `${message}
+
+${options.body}` : message;
+  if (fullMessage.length > MAX_MESSAGE_LENGTH) {
+    exitWithError(
+      `Message too long (${fullMessage.length} chars). Maximum is ${MAX_MESSAGE_LENGTH} characters.`
+    );
+  }
+  if (options.encodeOnly) {
+    const readOnlyOptions = parseReadOnlyOptionsWithDefault({
+      chainId: options.chainId,
+      rpcUrl: options.rpcUrl
+    });
+    const client2 = createFeedClient(readOnlyOptions);
+    const txConfig2 = client2.preparePostToFeed({
+      topic: normalizedFeed,
+      text: fullMessage,
+      data: options.data
+    });
+    const encoded = encodeTransaction(txConfig2, readOnlyOptions.chainId);
+    printJson(encoded);
+    return;
+  }
+  const commonOptions = parseCommonOptionsWithDefault(
+    {
+      privateKey: options.privateKey,
+      chainId: options.chainId,
+      rpcUrl: options.rpcUrl
+    },
+    true
+    // supports --encode-only
+  );
+  const client = createFeedClient(commonOptions);
+  const txConfig = client.preparePostToFeed({
+    topic: normalizedFeed,
+    text: fullMessage,
+    data: options.data
+  });
+  const walletClient = createWallet(
+    commonOptions.privateKey,
+    commonOptions.chainId,
+    commonOptions.rpcUrl
+  );
+  console.log(chalk4.blue(`Posting to feed "${normalizedFeed}"...`));
+  try {
+    const hash = await executeTransaction(walletClient, txConfig);
+    const senderAddress = walletClient.account.address;
+    let postId;
+    try {
+      const posts = await client.getFeedPosts({
+        topic: normalizedFeed,
+        maxPosts: 10
+      });
+      const ourPost = posts.find(
+        (p) => p.sender.toLowerCase() === senderAddress.toLowerCase() && p.text === fullMessage
+      );
+      if (ourPost) {
+        postId = `${ourPost.sender}:${ourPost.timestamp}`;
+      }
+    } catch {
+    }
+    addHistoryEntry({
+      type: "post",
+      txHash: hash,
+      chainId: commonOptions.chainId,
+      feed: normalizedFeed,
+      sender: senderAddress,
+      text: fullMessage,
+      postId
+      // Now we have the actual post ID for checking comments later
+    });
+    const displayText = options.body ? `${message} (+ body)` : message;
+    const postIdInfo = postId ? `
+  Post ID: ${postId}` : "";
+    console.log(
+      chalk4.green(
+        `Message posted successfully!
+  Transaction: ${hash}
+  Feed: ${normalizedFeed}${postIdInfo}
+  Text: ${displayText}`
+      )
+    );
+  } catch (error) {
+    exitWithError(
+      `Failed to post message: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+function registerFeedPostCommand(parent) {
+  parent.command("post <feed> <message>").description("Post a message to a feed").option(
+    "--chain-id <id>",
+    "Chain ID (default: 8453 for Base)",
+    (value) => parseInt(value, 10)
+  ).option("--rpc-url <url>", "Custom RPC URL").option("--private-key <key>", "Private key (0x-prefixed)").option(
+    "--encode-only",
+    "Output transaction data as JSON instead of executing"
+  ).option("--data <data>", "Optional data to attach to the post").option("--body <text>", "Post body (message becomes the title)").action(async (feed, message, options) => {
+    await executeFeedPost(feed, message, options);
+  });
+}
+
+// src/shared/postId.ts
+function parsePostId(postId) {
+  const parts = postId.split(":");
+  if (parts.length !== 2) {
+    throw new Error(
+      `Invalid post ID format. Expected {sender}:{timestamp}, got: ${postId}`
+    );
+  }
+  const [sender, timestampStr] = parts;
+  if (!sender.startsWith("0x") || sender.length !== 42) {
+    throw new Error(`Invalid sender address in post ID: ${sender}`);
+  }
+  const timestamp = BigInt(timestampStr);
+  if (timestamp <= 0) {
+    throw new Error(`Invalid timestamp in post ID: ${timestampStr}`);
+  }
+  return {
+    sender,
+    timestamp
+  };
+}
+function findPostByParsedId(posts, parsedId) {
+  return posts.find(
+    (p) => p.sender.toLowerCase() === parsedId.sender.toLowerCase() && p.timestamp === parsedId.timestamp
+  );
+}
+
+// src/commands/feed/comment-write.ts
+var MAX_MESSAGE_LENGTH2 = 4e3;
+async function executeFeedCommentWrite(feed, postId, message, options) {
+  const normalizedFeed = normalizeFeedName(feed);
+  if (message.length === 0) {
+    exitWithError("Comment cannot be empty");
+  }
+  if (message.length > MAX_MESSAGE_LENGTH2) {
+    exitWithError(
+      `Comment too long (${message.length} chars). Maximum is ${MAX_MESSAGE_LENGTH2} characters.`
+    );
+  }
+  let parsedId;
+  try {
+    parsedId = parsePostId(postId);
+  } catch (error) {
+    exitWithError(
+      error instanceof Error ? error.message : "Invalid post ID format"
+    );
+  }
+  const readOnlyOptions = parseReadOnlyOptionsWithDefault({
+    chainId: options.chainId,
+    rpcUrl: options.rpcUrl
+  });
+  const client = createFeedClient(readOnlyOptions);
+  const count = await client.getFeedPostCount(normalizedFeed);
+  if (count === 0) {
+    exitWithError(
+      `Feed "${normalizedFeed}" has no posts. Cannot find post ${postId}.`
+    );
+  }
+  const posts = await client.getFeedPosts({
+    topic: normalizedFeed,
+    maxPosts: 100
+    // Fetch enough to find the post
+  });
+  const targetPost = findPostByParsedId(posts, parsedId);
+  if (!targetPost) {
+    exitWithError(
+      `Post not found with ID ${postId} in feed "${normalizedFeed}". Make sure the sender and timestamp are correct.`
+    );
+  }
+  const txConfig = client.prepareComment({
+    post: targetPost,
+    text: message
+  });
+  if (options.encodeOnly) {
+    const encoded = encodeTransaction(txConfig, readOnlyOptions.chainId);
+    printJson(encoded);
+    return;
+  }
+  const commonOptions = parseCommonOptionsWithDefault(
+    {
+      privateKey: options.privateKey,
+      chainId: options.chainId,
+      rpcUrl: options.rpcUrl
+    },
+    true
+    // supports --encode-only
+  );
+  const walletClient = createWallet(
+    commonOptions.privateKey,
+    commonOptions.chainId,
+    commonOptions.rpcUrl
+  );
+  console.log(chalk4.blue(`Commenting on post ${postId}...`));
+  try {
+    const hash = await executeTransaction(walletClient, txConfig);
+    addHistoryEntry({
+      type: "comment",
+      txHash: hash,
+      chainId: commonOptions.chainId,
+      feed: normalizedFeed,
+      sender: walletClient.account.address,
+      text: message,
+      postId
+    });
+    console.log(
+      chalk4.green(
+        `Comment posted successfully!
+  Transaction: ${hash}
+  Post: ${postId}
+  Comment: ${message}`
+      )
+    );
+  } catch (error) {
+    exitWithError(
+      `Failed to post comment: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+function registerFeedCommentWriteCommand(parent) {
+  parent.command("comment <feed> <post-id> <message>").description(
+    "Comment on a post. Post ID format: {sender}:{timestamp}"
+  ).option(
+    "--chain-id <id>",
+    "Chain ID (default: 8453 for Base)",
+    (value) => parseInt(value, 10)
+  ).option("--rpc-url <url>", "Custom RPC URL").option("--private-key <key>", "Private key (0x-prefixed)").option(
+    "--encode-only",
+    "Output transaction data as JSON instead of executing"
+  ).action(async (feed, postId, message, options) => {
+    await executeFeedCommentWrite(feed, postId, message, options);
+  });
+}
+async function executeFeedCommentRead(feed, postId, options) {
+  const normalizedFeed = normalizeFeedName(feed);
+  const readOnlyOptions = parseReadOnlyOptionsWithDefault({
+    chainId: options.chainId,
+    rpcUrl: options.rpcUrl
+  });
+  const client = createFeedClient(readOnlyOptions);
+  let parsedId;
+  try {
+    parsedId = parsePostId(postId);
+  } catch (error) {
+    exitWithError(
+      error instanceof Error ? error.message : "Invalid post ID format"
+    );
+  }
+  try {
+    const count = await client.getFeedPostCount(normalizedFeed);
+    if (count === 0) {
+      exitWithError(
+        `Feed "${normalizedFeed}" has no posts. Cannot find post ${postId}.`
+      );
+    }
+    const posts = await client.getFeedPosts({
+      topic: normalizedFeed,
+      maxPosts: 100
+      // Fetch enough to find the post
+    });
+    const targetPost = findPostByParsedId(posts, parsedId);
+    if (!targetPost) {
+      exitWithError(
+        `Post not found with ID ${postId} in feed "${normalizedFeed}". Make sure the sender and timestamp are correct.`
+      );
+    }
+    const commentCount = await client.getCommentCount(targetPost);
+    if (commentCount === 0) {
+      if (options.json) {
+        printJson([]);
+      } else {
+        console.log(chalk4.yellow(`No comments found for post ${postId}`));
+      }
+      return;
+    }
+    const comments = await client.getComments({
+      post: targetPost,
+      maxComments: options.limit ?? 50
+    });
+    const commentsWithDepth = comments.map((comment) => ({
+      comment,
+      depth: 0
+    }));
+    if (options.json) {
+      printJson(
+        commentsWithDepth.map(
+          ({ comment, depth }) => commentToJson(comment, depth)
+        )
+      );
+    } else {
+      if (comments.length === 0) {
+        console.log(chalk4.yellow(`No comments found for post ${postId}`));
+        return;
+      }
+      console.log(
+        chalk4.white(`Found ${comments.length} comment(s) for post ${postId}:
+`)
+      );
+      commentsWithDepth.forEach(({ comment, depth }, i) => {
+        console.log(formatComment(comment, depth));
+        if (i < commentsWithDepth.length - 1) {
+          console.log();
+        }
+      });
+    }
+  } catch (error) {
+    if (error.message?.includes("Post not found")) {
+      throw error;
+    }
+    exitWithError(
+      `Failed to fetch comments: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+function registerFeedCommentReadCommand(parent) {
+  parent.command("comments <feed> <post-id>").description(
+    "Read comments on a post. Post ID format: {sender}:{timestamp}"
+  ).option(
+    "--limit <n>",
+    "Maximum number of comments to display",
+    (value) => parseInt(value, 10)
+  ).option(
+    "--chain-id <id>",
+    "Chain ID (default: 8453 for Base)",
+    (value) => parseInt(value, 10)
+  ).option("--rpc-url <url>", "Custom RPC URL").option("--json", "Output in JSON format").action(async (feed, postId, options) => {
+    await executeFeedCommentRead(feed, postId, options);
+  });
+}
+async function executeFeedRegister(feedName, options) {
+  if (feedName.length > 64) {
+    exitWithError("Feed name cannot exceed 64 characters");
+  }
+  if (feedName.length === 0) {
+    exitWithError("Feed name cannot be empty");
+  }
+  if (options.encodeOnly) {
+    const readOnlyOptions = parseReadOnlyOptionsWithDefault({
+      chainId: options.chainId,
+      rpcUrl: options.rpcUrl
+    });
+    const client2 = createFeedRegistryClient(readOnlyOptions);
+    const txConfig2 = client2.prepareRegisterFeed({ feedName });
+    const encoded = encodeTransaction(txConfig2, readOnlyOptions.chainId);
+    printJson(encoded);
+    return;
+  }
+  const commonOptions = parseCommonOptionsWithDefault(
+    {
+      privateKey: options.privateKey,
+      chainId: options.chainId,
+      rpcUrl: options.rpcUrl
+    },
+    true
+    // supports --encode-only
+  );
+  const client = createFeedRegistryClient(commonOptions);
+  const isRegistered = await client.isFeedRegistered(feedName);
+  if (isRegistered) {
+    exitWithError(`Feed "${feedName}" is already registered`);
+  }
+  const txConfig = client.prepareRegisterFeed({ feedName });
+  const walletClient = createWallet(
+    commonOptions.privateKey,
+    commonOptions.chainId,
+    commonOptions.rpcUrl
+  );
+  console.log(chalk4.blue(`Registering feed "${feedName}"...`));
+  try {
+    const hash = await executeTransaction(walletClient, txConfig);
+    addHistoryEntry({
+      type: "register",
+      txHash: hash,
+      chainId: commonOptions.chainId,
+      feed: feedName,
+      sender: walletClient.account.address
+    });
+    console.log(
+      chalk4.green(
+        `Feed registered successfully!
+  Transaction: ${hash}
+  Feed: ${feedName}`
+      )
+    );
+  } catch (error) {
+    exitWithError(
+      `Failed to register feed: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+function registerFeedRegisterCommand(parent) {
+  parent.command("register <feed-name>").description("Register a new feed").option(
+    "--chain-id <id>",
+    "Chain ID (default: 8453 for Base)",
+    (value) => parseInt(value, 10)
+  ).option("--rpc-url <url>", "Custom RPC URL").option("--private-key <key>", "Private key (0x-prefixed)").option(
+    "--encode-only",
+    "Output transaction data as JSON instead of executing"
+  ).action(async (feedName, options) => {
+    await executeFeedRegister(feedName, options);
+  });
+}
+function truncateText(text, maxLen) {
+  if (text.length <= maxLen) return text;
+  return text.slice(0, maxLen) + "...";
+}
+async function executeFeedReplies(options) {
+  const postHistory = getHistoryByType("post", options.limit ?? 10);
+  const postsWithIds = postHistory.filter(
+    (entry) => !!entry.postId
+  );
+  if (postsWithIds.length === 0) {
+    if (options.json) {
+      printJson([]);
+    } else {
+      console.log(chalk4.gray("No posts with trackable IDs found in history."));
+      console.log(
+        chalk4.gray("Post IDs are captured when you post with a wallet.")
+      );
+    }
+    return;
+  }
+  const readOnlyOptions = parseReadOnlyOptionsWithDefault({
+    chainId: options.chainId,
+    rpcUrl: options.rpcUrl
+  });
+  const client = createFeedClient(readOnlyOptions);
+  console.log(chalk4.blue(`Checking replies on ${postsWithIds.length} posts...
+`));
+  const results = [];
+  for (const entry of postsWithIds) {
+    try {
+      const [sender, timestampStr] = entry.postId.split(":");
+      const timestamp = BigInt(timestampStr);
+      const postObj = {
+        sender,
+        timestamp,
+        text: entry.text ?? "",
+        topic: entry.feed,
+        app: "",
+        data: "0x"
+      };
+      const commentCount = await client.getCommentCount(postObj);
+      results.push({
+        feed: entry.feed,
+        postId: entry.postId,
+        text: entry.text ?? "",
+        postedAt: entry.timestamp,
+        commentCount: Number(commentCount)
+      });
+    } catch {
+    }
+  }
+  if (options.json) {
+    printJson(results);
+    return;
+  }
+  const postsWithReplies = results.filter((r) => r.commentCount > 0);
+  const totalReplies = results.reduce((sum, r) => sum + r.commentCount, 0);
+  console.log(
+    chalk4.cyan(
+      `Found ${totalReplies} total replies across ${postsWithReplies.length} posts
+`
+    )
+  );
+  if (results.length === 0) {
+    console.log(chalk4.gray("Could not check any posts."));
+    return;
+  }
+  results.sort((a, b) => b.commentCount - a.commentCount);
+  for (const post of results) {
+    const timeAgo = formatTimestamp(post.postedAt);
+    const replyText = post.commentCount === 0 ? chalk4.gray("no replies") : post.commentCount === 1 ? chalk4.green("1 reply") : chalk4.green(`${post.commentCount} replies`);
+    console.log(
+      `${chalk4.white(post.feed)} ${chalk4.gray("\u2022")} ${replyText} ${chalk4.gray(`\u2022 ${timeAgo}`)}`
+    );
+    console.log(`  ${chalk4.gray(truncateText(post.text, 60))}`);
+    if (post.commentCount > 0) {
+      console.log(
+        chalk4.blue(`  \u2192 netp feed comments ${post.feed} ${post.postId}`)
+      );
+    }
+    console.log("");
+  }
+}
+function registerFeedRepliesCommand(parent) {
+  parent.command("replies").description("Check for replies on your recent posts").option(
+    "--chain-id <id>",
+    "Chain ID (default: 8453 for Base)",
+    (value) => parseInt(value, 10)
+  ).option("--rpc-url <url>", "Custom RPC URL").option(
+    "--limit <n>",
+    "Number of recent posts to check (default: 10)",
+    (value) => parseInt(value, 10)
+  ).option("--json", "Output as JSON").action(async (options) => {
+    await executeFeedReplies(options);
+  });
+}
+async function executeFeedPosts(address, options) {
+  if (!address.startsWith("0x") || address.length !== 42) {
+    exitWithError("Invalid address format. Must be 0x-prefixed, 42 characters");
+  }
+  const readOnlyOptions = parseReadOnlyOptionsWithDefault({
+    chainId: options.chainId,
+    rpcUrl: options.rpcUrl
+  });
+  const client = createNetClient(readOnlyOptions);
+  const limit = options.limit ?? 20;
+  try {
+    const count = await client.getMessageCount({
+      filter: {
+        appAddress: NULL_ADDRESS,
+        maker: address
+      }
+    });
+    if (count === 0) {
+      if (options.json) {
+        printJson([]);
+      } else {
+        console.log(chalk4.yellow(`No posts found for address ${address}`));
+      }
+      return;
+    }
+    const startIndex = count > limit ? count - limit : 0;
+    const messages = await client.getMessages({
+      filter: {
+        appAddress: NULL_ADDRESS,
+        maker: address
+      },
+      startIndex,
+      endIndex: count
+    });
+    if (options.json) {
+      printJson(messages.map((msg, i) => postToJson(msg, i)));
+    } else {
+      console.log(
+        chalk4.white(`Found ${messages.length} post(s) by ${address}:
+`)
+      );
+      messages.forEach((msg, i) => {
+        console.log(formatPost(msg, i, { showTopic: true }));
+        if (i < messages.length - 1) {
+          console.log();
+        }
+      });
+    }
+  } catch (error) {
+    exitWithError(
+      `Failed to fetch posts: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+function registerFeedPostsCommand(parent) {
+  parent.command("posts <address>").description("View posts by an address").option(
+    "--limit <n>",
+    "Maximum number of posts to display",
+    (value) => parseInt(value, 10)
+  ).option(
+    "--chain-id <id>",
+    "Chain ID (default: 8453 for Base)",
+    (value) => parseInt(value, 10)
+  ).option("--rpc-url <url>", "Custom RPC URL").option("--json", "Output in JSON format").action(async (address, options) => {
+    await executeFeedPosts(address, options);
+  });
+}
+async function confirm(message) {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  return new Promise((resolve3) => {
+    rl.question(`${message} (y/N): `, (answer) => {
+      rl.close();
+      resolve3(answer.toLowerCase() === "y" || answer.toLowerCase() === "yes");
+    });
+  });
+}
+
+// src/commands/feed/config.ts
+async function executeFeedConfig(options) {
+  if (options.reset) {
+    const statePath = getStateFilePath();
+    console.log(chalk4.yellow(`This will delete all stored state at:`));
+    console.log(chalk4.white(`  ${statePath}`));
+    console.log(chalk4.yellow(`
+This includes:`));
+    console.log(chalk4.white(`  - All "last seen" timestamps for feeds`));
+    console.log(chalk4.white(`  - Your configured address`));
+    console.log(chalk4.white(`  - Your activity history`));
+    if (!options.force) {
+      const confirmed = await confirm(chalk4.red("\nAre you sure you want to reset?"));
+      if (!confirmed) {
+        console.log(chalk4.gray("Cancelled."));
+        return;
+      }
+    }
+    resetState();
+    console.log(chalk4.green("State reset successfully."));
+    return;
+  }
+  if (options.myAddress) {
+    if (!options.myAddress.match(/^0x[a-fA-F0-9]{40}$/)) {
+      console.error(chalk4.red("Invalid address format. Expected 0x followed by 40 hex characters."));
+      process.exit(1);
+    }
+    setMyAddress(options.myAddress);
+    console.log(chalk4.green(`Set my address to: ${options.myAddress}`));
+    return;
+  }
+  if (options.clearAddress) {
+    clearMyAddress();
+    console.log(chalk4.green("Cleared my address."));
+    return;
+  }
+  const state = getFullState();
+  const myAddress = getMyAddress();
+  console.log(chalk4.cyan("Feed Configuration\n"));
+  console.log(chalk4.white(`State file: ${getStateFilePath()}`));
+  console.log(chalk4.white(`My address: ${myAddress ?? chalk4.gray("(not set)")}`));
+  const feedCount = Object.keys(state.feeds).length;
+  console.log(chalk4.white(`Tracked feeds: ${feedCount}`));
+  const historyCount = getHistoryCount();
+  console.log(chalk4.white(`History entries: ${historyCount}`));
+  if (feedCount > 0 && feedCount <= 20) {
+    console.log(chalk4.gray("\nLast seen timestamps:"));
+    for (const [feed, data] of Object.entries(state.feeds)) {
+      const date = new Date(data.lastSeenTimestamp * 1e3);
+      console.log(chalk4.gray(`  ${feed}: ${date.toLocaleString()}`));
+    }
+  } else if (feedCount > 20) {
+    console.log(chalk4.gray(`
+(${feedCount} feeds tracked, use --json for full list)`));
+  }
+  const activeFeeds = getActiveFeeds();
+  if (activeFeeds.length > 0) {
+    console.log(chalk4.cyan("\nActive Feeds:"));
+    const displayFeeds = activeFeeds.slice(0, 10);
+    for (const feed of displayFeeds) {
+      const activity = [];
+      if (feed.postCount > 0) activity.push(`${feed.postCount} post${feed.postCount !== 1 ? "s" : ""}`);
+      if (feed.commentCount > 0) activity.push(`${feed.commentCount} comment${feed.commentCount !== 1 ? "s" : ""}`);
+      const lastActive = formatTimestamp(feed.lastActivity);
+      console.log(chalk4.white(`  ${feed.feed}`) + chalk4.gray(` \u2022 ${activity.join(", ")} \u2022 ${lastActive}`));
+    }
+    if (activeFeeds.length > 10) {
+      console.log(chalk4.gray(`  ... and ${activeFeeds.length - 10} more`));
+    }
+  }
+  const contacts = getContacts();
+  if (contacts.length > 0) {
+    console.log(chalk4.cyan("\nRecent Contacts (DMs):"));
+    const displayContacts = contacts.slice(0, 10);
+    for (const contact of displayContacts) {
+      const truncAddr = `${contact.address.slice(0, 6)}...${contact.address.slice(-4)}`;
+      const msgCount = contact.interactionCount;
+      const lastActive = formatTimestamp(contact.lastInteraction);
+      console.log(
+        chalk4.white(`  ${truncAddr}`) + chalk4.gray(` \u2022 ${msgCount} message${msgCount !== 1 ? "s" : ""} \u2022 ${lastActive}`)
+      );
+    }
+    if (contacts.length > 10) {
+      console.log(chalk4.gray(`  ... and ${contacts.length - 10} more`));
+    }
+  }
+}
+function registerFeedConfigCommand(parent) {
+  parent.command("config").description("View or modify feed configuration").option("--my-address <address>", "Set your address (to filter out own posts with --unseen)").option("--clear-address", "Clear your configured address").option("--show", "Show current configuration (default)").option("--reset", "Reset all state (clears last-seen timestamps and address)").option("--force", "Skip confirmation prompt for --reset").action(async (options) => {
+    await executeFeedConfig(options);
+  });
+}
+function formatHistoryEntry(entry, index) {
+  const timestamp = formatTimestamp(entry.timestamp);
+  const typeColor = entry.type === "post" ? chalk4.green : entry.type === "comment" ? chalk4.blue : chalk4.yellow;
+  const lines = [
+    chalk4.cyan(`[${index}]`) + ` ${chalk4.gray(timestamp)} ` + typeColor(entry.type.toUpperCase()),
+    `  ${chalk4.white("Feed:")} ${entry.feed}`,
+    `  ${chalk4.white("Tx:")} ${entry.txHash}`
+  ];
+  if (entry.sender) {
+    lines.push(`  ${chalk4.white("Sender:")} ${truncateAddress(entry.sender)}`);
+  }
+  if (entry.text) {
+    const truncatedText = entry.text.length > 80 ? entry.text.slice(0, 80) + "..." : entry.text;
+    lines.push(`  ${chalk4.white("Text:")} ${truncatedText}`);
+  }
+  if (entry.type === "post" && entry.postId) {
+    lines.push(`  ${chalk4.white("Post ID:")} ${entry.postId}`);
+  } else if (entry.type === "comment" && entry.postId) {
+    lines.push(`  ${chalk4.white("Reply to:")} ${entry.postId}`);
+  }
+  if (entry.type === "post" && entry.postId) {
+    lines.push(
+      chalk4.gray(`  \u2192 Check replies: netp feed comments ${entry.feed} ${entry.postId}`)
+    );
+  } else if (entry.type === "post" && entry.sender) {
+    lines.push(
+      chalk4.gray(`  \u2192 Find post: netp feed read ${entry.feed} --sender ${entry.sender} --json`)
+    );
+  } else if (entry.type === "comment" && entry.postId) {
+    lines.push(
+      chalk4.gray(`  \u2192 See thread: netp feed comments ${entry.feed} ${entry.postId}`)
+    );
+  }
+  return lines.join("\n");
+}
+function historyEntryToJson(entry, index) {
+  const result = {
+    index,
+    type: entry.type,
+    timestamp: entry.timestamp,
+    txHash: entry.txHash,
+    chainId: entry.chainId,
+    feed: entry.feed
+  };
+  if (entry.sender) {
+    result.sender = entry.sender;
+  }
+  if (entry.text) {
+    result.text = entry.text;
+  }
+  if (entry.postId) {
+    result.postId = entry.postId;
+  }
+  return result;
+}
+function validateType(type) {
+  const validTypes = ["post", "comment", "register"];
+  if (!validTypes.includes(type)) {
+    console.error(
+      chalk4.red(
+        `Invalid type "${type}". Must be one of: ${validTypes.join(", ")}`
+      )
+    );
+    process.exit(1);
+  }
+  return type;
+}
+async function executeFeedHistory(options) {
+  if (options.clear) {
+    const count = getHistoryCount();
+    if (count === 0) {
+      console.log(chalk4.gray("History is already empty."));
+      return;
+    }
+    console.log(chalk4.yellow(`This will delete ${count} history entries.`));
+    if (!options.force) {
+      const confirmed = await confirm(
+        chalk4.red("\nAre you sure you want to clear history?")
+      );
+      if (!confirmed) {
+        console.log(chalk4.gray("Cancelled."));
+        return;
+      }
+    }
+    clearHistory();
+    console.log(chalk4.green("History cleared."));
+    return;
+  }
+  let entries;
+  if (options.type) {
+    const validType = validateType(options.type);
+    entries = getHistoryByType(validType, options.limit);
+  } else {
+    entries = getHistory(options.limit);
+  }
+  if (entries.length === 0) {
+    if (options.json) {
+      printJson([]);
+    } else {
+      console.log(chalk4.gray("No history entries found."));
+      console.log(
+        chalk4.gray(
+          "History is recorded when you post, comment, or register feeds."
+        )
+      );
+    }
+    return;
+  }
+  if (options.json) {
+    const jsonEntries = entries.map(
+      (entry, idx) => historyEntryToJson(entry, idx)
+    );
+    printJson(jsonEntries);
+  } else {
+    const totalCount = getHistoryCount();
+    const typeFilter = options.type ? ` (type: ${options.type})` : "";
+    console.log(
+      chalk4.cyan(`Feed History${typeFilter} (${entries.length} of ${totalCount})
+`)
+    );
+    for (let i = 0; i < entries.length; i++) {
+      console.log(formatHistoryEntry(entries[i], i));
+      if (i < entries.length - 1) {
+        console.log("");
+      }
+    }
+  }
+}
+function registerFeedHistoryCommand(parent) {
+  parent.command("history").description("View feed activity history (posts, comments, registrations)").option(
+    "--limit <n>",
+    "Limit number of entries",
+    (value) => parseInt(value, 10)
+  ).option("--type <type>", "Filter by type: post, comment, or register").option("--json", "Output as JSON").option("--clear", "Clear all history").option("--force", "Skip confirmation prompt for --clear").action(async (options) => {
+    await executeFeedHistory(options);
+  });
+}
+
+// src/commands/feed/index.ts
+function registerFeedCommand(program2) {
+  const feedCommand = program2.command("feed").description("Feed operations (read/write posts, comments, manage feeds)");
+  registerFeedListCommand(feedCommand);
+  registerFeedReadCommand(feedCommand);
+  registerFeedPostCommand(feedCommand);
+  registerFeedCommentWriteCommand(feedCommand);
+  registerFeedCommentReadCommand(feedCommand);
+  registerFeedRegisterCommand(feedCommand);
+  registerFeedRepliesCommand(feedCommand);
+  registerFeedPostsCommand(feedCommand);
+  registerFeedConfigCommand(feedCommand);
+  registerFeedHistoryCommand(feedCommand);
 }
 
 // src/cli/index.ts
@@ -4171,6 +6398,7 @@ registerInfoCommand(program);
 registerTokenCommand(program);
 registerProfileCommand(program);
 registerBazaarCommand(program);
+registerFeedCommand(program);
 program.parse();
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map