@net-protocol/cli 0.1.48 → 0.2.1

package/dist/cli/index.mjs

@@ -22,7 +22,7 @@ import { BazaarClient } from '@net-protocol/bazaar';
 import * as os from 'os';
 import { homedir } from 'os';
 import * as readline from 'readline';
-import { discoverTokenPool, PURE_ALPHA_STRATEGY, UNIV234_POOLS_STRATEGY, encodePoolKey, DYNAMIC_SPLIT_STRATEGY, getTokenScoreKey, UPVOTE_PRICE_ETH, UPVOTE_APP, ScoreClient, ALL_STRATEGY_ADDRESSES, NULL_ADDRESS as NULL_ADDRESS$1, UserUpvoteClient, calculateUpvoteCost, USER_UPVOTE_CONTRACT } from '@net-protocol/score';
+import { discoverTokenPool, PURE_ALPHA_STRATEGY, UNIV234_POOLS_STRATEGY, encodePoolKey, DYNAMIC_SPLIT_STRATEGY, getTokenScoreKey, UPVOTE_PRICE_ETH, UPVOTE_APP, ScoreClient, ALL_STRATEGY_ADDRESSES, NULL_ADDRESS as NULL_ADDRESS$1, UserUpvoteClient, calculateUpvoteCost, USER_UPVOTE_CONTRACT, getTokenRankings } from '@net-protocol/score';
 import { RELAY_ACCESS_KEY, generateAgentChatTopic, AgentClient, isAgentChatTopic, parseAgentAddressFromTopic, buildSessionTypedData, NET_API_URL, exchangeSessionSignature, buildConversationAuthTypedData, NET_TESTNET_API_URL } from '@net-protocol/agents';
 
 var DEFAULT_CHAIN_ID = 8453;
@@ -1641,8 +1641,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: privateKeyToAccount28 } = await import('viem/accounts');
-      const userAccount = privateKeyToAccount28(commonOptions.privateKey);
+      const { privateKeyToAccount: privateKeyToAccount32 } = await import('viem/accounts');
+      const userAccount = privateKeyToAccount32(commonOptions.privateKey);
       const storageUrl2 = generateStorageUrl(
         userAccount.address,
         commonOptions.chainId,
@@ -4795,7 +4795,8 @@ async function executeCreateErc20Listing(options) {
       tokenAddress: options.tokenAddress,
       tokenAmount,
       priceWei,
-      offerer: account.address
+      offerer: account.address,
+      targetFulfiller: options.targetFulfiller
     });
     const rpcUrls = getChainRpcUrls({
       chainId: commonOptions.chainId,
@@ -4879,7 +4880,8 @@ async function executeKeylessMode3(options) {
       tokenAddress: options.tokenAddress,
       tokenAmount,
       priceWei,
-      offerer: options.offerer
+      offerer: options.offerer,
+      targetFulfiller: options.targetFulfiller
     });
     const output = {
       eip712: {
@@ -5487,6 +5489,386 @@ async function executeEncodeOnly10(options) {
     );
   }
 }
+function createWallet(privateKey, chainId, rpcUrl) {
+  const account = privateKeyToAccount(privateKey);
+  const rpcUrls = getChainRpcUrls({
+    chainId,
+    rpcUrl
+  });
+  return createWalletClient({
+    account,
+    transport: http(rpcUrls[0]),
+    dataSuffix: getBaseDataSuffix(chainId)
+  });
+}
+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/bazaar/cancel-listing.ts
+async function executeCancelListing(options) {
+  if (options.encodeOnly) {
+    await executeEncodeOnly11(options);
+    return;
+  }
+  const commonOptions = parseCommonOptions(
+    {
+      privateKey: options.privateKey,
+      chainId: options.chainId,
+      rpcUrl: options.rpcUrl
+    },
+    true
+  );
+  const account = privateKeyToAccount(commonOptions.privateKey);
+  const bazaarClient = new BazaarClient({
+    chainId: commonOptions.chainId,
+    rpcUrl: commonOptions.rpcUrl
+  });
+  try {
+    console.log(chalk4.blue("Fetching listing..."));
+    const listings = await bazaarClient.getListings({
+      nftAddress: options.nftAddress,
+      maker: account.address,
+      includeExpired: true
+    });
+    const listing = listings.find(
+      (l) => l.orderHash.toLowerCase() === options.orderHash.toLowerCase()
+    );
+    if (!listing) {
+      exitWithError(
+        `Listing with order hash ${options.orderHash} not found for maker ${account.address}`
+      );
+    }
+    const cancelTx = bazaarClient.prepareCancelListing(listing);
+    const walletClient = createWallet(
+      commonOptions.privateKey,
+      commonOptions.chainId,
+      commonOptions.rpcUrl
+    );
+    console.log(chalk4.blue("Sending cancel transaction..."));
+    const hash = await executeTransaction(walletClient, cancelTx);
+    console.log(
+      chalk4.green(
+        `Listing cancelled successfully!
+  Transaction: ${hash}
+  NFT: ${listing.nftAddress} #${listing.tokenId}`
+      )
+    );
+  } catch (error) {
+    exitWithError(
+      `Failed to cancel listing: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+async function executeEncodeOnly11(options) {
+  if (!options.maker) {
+    exitWithError("--maker is required when using --encode-only without --private-key");
+  }
+  const readOnlyOptions = parseReadOnlyOptions({
+    chainId: options.chainId,
+    rpcUrl: options.rpcUrl
+  });
+  const makerAddress = options.maker;
+  const bazaarClient = new BazaarClient({
+    chainId: readOnlyOptions.chainId,
+    rpcUrl: readOnlyOptions.rpcUrl
+  });
+  try {
+    const listings = await bazaarClient.getListings({
+      nftAddress: options.nftAddress,
+      maker: makerAddress,
+      includeExpired: true
+    });
+    const listing = listings.find(
+      (l) => l.orderHash.toLowerCase() === options.orderHash.toLowerCase()
+    );
+    if (!listing) {
+      exitWithError(
+        `Listing with order hash ${options.orderHash} not found for maker ${makerAddress}`
+      );
+    }
+    const cancelTx = bazaarClient.prepareCancelListing(listing);
+    console.log(JSON.stringify(encodeTransaction(cancelTx, readOnlyOptions.chainId), null, 2));
+  } catch (error) {
+    exitWithError(
+      `Failed to encode cancel listing: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+async function executeCancelOffer(options) {
+  if (options.encodeOnly) {
+    await executeEncodeOnly12(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 collection offer..."));
+    const offers = await bazaarClient.getCollectionOffers({
+      nftAddress: options.nftAddress,
+      maker: account.address
+    });
+    const offer = offers.find(
+      (o) => o.orderHash.toLowerCase() === options.orderHash.toLowerCase()
+    );
+    if (!offer) {
+      exitWithError(
+        `Offer with order hash ${options.orderHash} not found for maker ${account.address}`
+      );
+    }
+    const cancelTx = bazaarClient.prepareCancelCollectionOffer(offer);
+    const walletClient = createWallet(
+      commonOptions.privateKey,
+      commonOptions.chainId,
+      commonOptions.rpcUrl
+    );
+    console.log(chalk4.blue("Sending cancel transaction..."));
+    const hash = await executeTransaction(walletClient, cancelTx);
+    console.log(
+      chalk4.green(
+        `Offer cancelled successfully!
+  Transaction: ${hash}
+  NFT: ${offer.nftAddress}
+  Price: ${offer.price} ${offer.currency.toUpperCase()}`
+      )
+    );
+  } catch (error) {
+    exitWithError(
+      `Failed to cancel offer: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+async function executeEncodeOnly12(options) {
+  if (!options.maker) {
+    exitWithError("--maker is required when using --encode-only without --private-key");
+  }
+  const readOnlyOptions = parseReadOnlyOptions({
+    chainId: options.chainId,
+    rpcUrl: options.rpcUrl
+  });
+  const makerAddress = options.maker;
+  const bazaarClient = new BazaarClient({
+    chainId: readOnlyOptions.chainId,
+    rpcUrl: readOnlyOptions.rpcUrl
+  });
+  try {
+    const offers = await bazaarClient.getCollectionOffers({
+      nftAddress: options.nftAddress,
+      maker: makerAddress
+    });
+    const offer = offers.find(
+      (o) => o.orderHash.toLowerCase() === options.orderHash.toLowerCase()
+    );
+    if (!offer) {
+      exitWithError(
+        `Offer with order hash ${options.orderHash} not found for maker ${makerAddress}`
+      );
+    }
+    const cancelTx = bazaarClient.prepareCancelCollectionOffer(offer);
+    console.log(JSON.stringify(encodeTransaction(cancelTx, readOnlyOptions.chainId), null, 2));
+  } catch (error) {
+    exitWithError(
+      `Failed to encode cancel offer: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+async function executeCancelErc20Listing(options) {
+  if (options.encodeOnly) {
+    await executeEncodeOnly13(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 ERC20 listing..."));
+    const listings = await bazaarClient.getErc20Listings({
+      tokenAddress: options.tokenAddress,
+      maker: account.address,
+      includeExpired: true
+    });
+    const listing = listings.find(
+      (l) => l.orderHash.toLowerCase() === options.orderHash.toLowerCase()
+    );
+    if (!listing) {
+      exitWithError(
+        `ERC20 listing with order hash ${options.orderHash} not found for maker ${account.address}`
+      );
+    }
+    const cancelTx = bazaarClient.prepareCancelErc20Listing(listing);
+    const walletClient = createWallet(
+      commonOptions.privateKey,
+      commonOptions.chainId,
+      commonOptions.rpcUrl
+    );
+    console.log(chalk4.blue("Sending cancel transaction..."));
+    const hash = await executeTransaction(walletClient, cancelTx);
+    console.log(
+      chalk4.green(
+        `ERC20 listing cancelled successfully!
+  Transaction: ${hash}
+  Token: ${listing.tokenAddress}
+  Amount: ${listing.tokenAmount.toString()}`
+      )
+    );
+  } catch (error) {
+    exitWithError(
+      `Failed to cancel ERC20 listing: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+async function executeEncodeOnly13(options) {
+  if (!options.maker) {
+    exitWithError("--maker is required when using --encode-only without --private-key");
+  }
+  const readOnlyOptions = parseReadOnlyOptions({
+    chainId: options.chainId,
+    rpcUrl: options.rpcUrl
+  });
+  const makerAddress = options.maker;
+  const bazaarClient = new BazaarClient({
+    chainId: readOnlyOptions.chainId,
+    rpcUrl: readOnlyOptions.rpcUrl
+  });
+  try {
+    const listings = await bazaarClient.getErc20Listings({
+      tokenAddress: options.tokenAddress,
+      maker: makerAddress,
+      includeExpired: true
+    });
+    const listing = listings.find(
+      (l) => l.orderHash.toLowerCase() === options.orderHash.toLowerCase()
+    );
+    if (!listing) {
+      exitWithError(
+        `ERC20 listing with order hash ${options.orderHash} not found for maker ${makerAddress}`
+      );
+    }
+    const cancelTx = bazaarClient.prepareCancelErc20Listing(listing);
+    console.log(JSON.stringify(encodeTransaction(cancelTx, readOnlyOptions.chainId), null, 2));
+  } catch (error) {
+    exitWithError(
+      `Failed to encode cancel ERC20 listing: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+async function executeCancelErc20Offer(options) {
+  if (options.encodeOnly) {
+    await executeEncodeOnly14(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 ERC20 offer..."));
+    const offers = await bazaarClient.getErc20Offers({
+      tokenAddress: options.tokenAddress,
+      maker: account.address
+    });
+    const offer = offers.find(
+      (o) => o.orderHash.toLowerCase() === options.orderHash.toLowerCase()
+    );
+    if (!offer) {
+      exitWithError(
+        `ERC20 offer with order hash ${options.orderHash} not found for maker ${account.address}`
+      );
+    }
+    const cancelTx = bazaarClient.prepareCancelErc20Offer(offer);
+    const walletClient = createWallet(
+      commonOptions.privateKey,
+      commonOptions.chainId,
+      commonOptions.rpcUrl
+    );
+    console.log(chalk4.blue("Sending cancel transaction..."));
+    const hash = await executeTransaction(walletClient, cancelTx);
+    console.log(
+      chalk4.green(
+        `ERC20 offer cancelled successfully!
+  Transaction: ${hash}
+  Token: ${offer.tokenAddress}
+  Amount: ${offer.tokenAmount.toString()}`
+      )
+    );
+  } catch (error) {
+    exitWithError(
+      `Failed to cancel ERC20 offer: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+async function executeEncodeOnly14(options) {
+  if (!options.maker) {
+    exitWithError("--maker is required when using --encode-only without --private-key");
+  }
+  const readOnlyOptions = parseReadOnlyOptions({
+    chainId: options.chainId,
+    rpcUrl: options.rpcUrl
+  });
+  const makerAddress = options.maker;
+  const bazaarClient = new BazaarClient({
+    chainId: readOnlyOptions.chainId,
+    rpcUrl: readOnlyOptions.rpcUrl
+  });
+  try {
+    const offers = await bazaarClient.getErc20Offers({
+      tokenAddress: options.tokenAddress,
+      maker: makerAddress
+    });
+    const offer = offers.find(
+      (o) => o.orderHash.toLowerCase() === options.orderHash.toLowerCase()
+    );
+    if (!offer) {
+      exitWithError(
+        `ERC20 offer with order hash ${options.orderHash} not found for maker ${makerAddress}`
+      );
+    }
+    const cancelTx = bazaarClient.prepareCancelErc20Offer(offer);
+    console.log(JSON.stringify(encodeTransaction(cancelTx, readOnlyOptions.chainId), null, 2));
+  } catch (error) {
+    exitWithError(
+      `Failed to encode cancel ERC20 offer: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
 
 // src/commands/bazaar/index.ts
 var chainIdOption = [
@@ -5620,11 +6002,12 @@ function registerBazaarCommand(program2) {
       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) => {
+  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("--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 executeCreateErc20Listing({
       tokenAddress: options.tokenAddress,
       tokenAmount: options.tokenAmount,
       price: options.price,
+      targetFulfiller: options.targetFulfiller,
       offerer: options.offerer,
       privateKey: options.privateKey,
       chainId: options.chainId,
@@ -5684,6 +6067,50 @@ function registerBazaarCommand(program2) {
       encodeOnly: options.encodeOnly
     });
   });
+  const cancelListingCommand = new Command("cancel-listing").description("Cancel an NFT listing you created").requiredOption("--order-hash <hash>", "Order hash of the listing to cancel").requiredOption("--nft-address <address>", "NFT contract address").option("--maker <address>", "Maker 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 executeCancelListing({
+      orderHash: options.orderHash,
+      nftAddress: options.nftAddress,
+      maker: options.maker,
+      privateKey: options.privateKey,
+      chainId: options.chainId,
+      rpcUrl: options.rpcUrl,
+      encodeOnly: options.encodeOnly
+    });
+  });
+  const cancelOfferCommand = new Command("cancel-offer").description("Cancel a collection offer you created").requiredOption("--order-hash <hash>", "Order hash of the offer to cancel").requiredOption("--nft-address <address>", "NFT contract address").option("--maker <address>", "Maker 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 executeCancelOffer({
+      orderHash: options.orderHash,
+      nftAddress: options.nftAddress,
+      maker: options.maker,
+      privateKey: options.privateKey,
+      chainId: options.chainId,
+      rpcUrl: options.rpcUrl,
+      encodeOnly: options.encodeOnly
+    });
+  });
+  const cancelErc20ListingCommand = new Command("cancel-erc20-listing").description("Cancel an ERC-20 listing you created").requiredOption("--order-hash <hash>", "Order hash of the listing to cancel").requiredOption("--token-address <address>", "ERC-20 token contract address").option("--maker <address>", "Maker 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 executeCancelErc20Listing({
+      orderHash: options.orderHash,
+      tokenAddress: options.tokenAddress,
+      maker: options.maker,
+      privateKey: options.privateKey,
+      chainId: options.chainId,
+      rpcUrl: options.rpcUrl,
+      encodeOnly: options.encodeOnly
+    });
+  });
+  const cancelErc20OfferCommand = new Command("cancel-erc20-offer").description("Cancel an ERC-20 offer you created").requiredOption("--order-hash <hash>", "Order hash of the offer to cancel").requiredOption("--token-address <address>", "ERC-20 token contract address").option("--maker <address>", "Maker 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 executeCancelErc20Offer({
+      orderHash: options.orderHash,
+      tokenAddress: options.tokenAddress,
+      maker: options.maker,
+      privateKey: options.privateKey,
+      chainId: options.chainId,
+      rpcUrl: options.rpcUrl,
+      encodeOnly: options.encodeOnly
+    });
+  });
   bazaarCommand.addCommand(listListingsCommand);
   bazaarCommand.addCommand(listOffersCommand);
   bazaarCommand.addCommand(listSalesCommand);
@@ -5702,6 +6129,10 @@ function registerBazaarCommand(program2) {
   bazaarCommand.addCommand(submitErc20OfferCommand);
   bazaarCommand.addCommand(buyErc20ListingCommand);
   bazaarCommand.addCommand(acceptErc20OfferCommand);
+  bazaarCommand.addCommand(cancelListingCommand);
+  bazaarCommand.addCommand(cancelOfferCommand);
+  bazaarCommand.addCommand(cancelErc20ListingCommand);
+  bazaarCommand.addCommand(cancelErc20OfferCommand);
 }
 function truncateAddress(address) {
   if (address.length <= 12) return address;
@@ -6172,29 +6603,6 @@ function registerFeedReadCommand(parent) {
     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]),
-    dataSuffix: getBaseDataSuffix(chainId)
-  });
-}
-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;
-}
 async function getMessageIndicesFromTx(params) {
   const publicClient = getPublicClient({
     chainId: params.chainId,
@@ -7872,6 +8280,155 @@ function registerGetUserUpvotesCommand(parent, commandName = "user-info") {
     await executeGetUserUpvotes(options);
   });
 }
+var VALID_SORTS = ["trending", "recent", "top"];
+function formatNumber(n, digits = 2) {
+  if (n == null || !Number.isFinite(n)) return "-";
+  if (n >= 1e9) return `${(n / 1e9).toFixed(digits)}B`;
+  if (n >= 1e6) return `${(n / 1e6).toFixed(digits)}M`;
+  if (n >= 1e3) return `${(n / 1e3).toFixed(digits)}K`;
+  return n.toFixed(digits);
+}
+function formatPrice(price) {
+  if (price == null || !Number.isFinite(price)) return "-";
+  if (price < 1e-6) return price.toExponential(2);
+  if (price < 1) return `$${price.toFixed(6)}`;
+  return `$${price.toFixed(4)}`;
+}
+async function executeRankings(options) {
+  const sort = (options.sort ?? "trending").toLowerCase();
+  if (!VALID_SORTS.includes(sort)) {
+    exitWithError(
+      `Invalid --sort "${options.sort}". Must be one of: ${VALID_SORTS.join(", ")}`
+    );
+    return;
+  }
+  const limit = options.limit ?? 10;
+  if (!Number.isFinite(limit) || limit < 1 || limit > 100) {
+    exitWithError("Invalid --limit. Must be an integer between 1 and 100.");
+    return;
+  }
+  const optionalPositiveInt = (value, name, { allowZero = false } = {}) => {
+    if (value === void 0) return void 0;
+    if (!Number.isFinite(value) || (allowZero ? value < 0 : value < 1)) {
+      exitWithError(
+        `Invalid ${name}. Must be a ${allowZero ? "non-negative" : "positive"} integer.`
+      );
+    }
+    return value;
+  };
+  const scanWindow = optionalPositiveInt(options.scanWindow, "--scan-window");
+  const minUpvotes = optionalPositiveInt(options.minUpvotes, "--min-upvotes", {
+    allowZero: true
+  });
+  const minMarketCap = optionalPositiveInt(
+    options.minMarketCap,
+    "--min-market-cap",
+    { allowZero: true }
+  );
+  const recencyHours = optionalPositiveInt(
+    options.recencyHours,
+    "--recency-hours",
+    { allowZero: true }
+  );
+  if (options.chainId !== void 0 && !Number.isFinite(options.chainId)) {
+    exitWithError("Invalid --chain-id. Must be an integer.");
+    return;
+  }
+  const readOnlyOptions = parseReadOnlyOptionsWithDefault({
+    chainId: options.chainId,
+    rpcUrl: options.rpcUrl
+  });
+  try {
+    const tokens = await getTokenRankings({
+      chainId: readOnlyOptions.chainId,
+      sort,
+      maxTokens: limit,
+      messageScanWindow: scanWindow,
+      thresholds: minUpvotes != null || minMarketCap != null || recencyHours != null ? {
+        minUpvotes,
+        minMarketCap,
+        recencyHours
+      } : void 0,
+      rpcUrl: readOnlyOptions.rpcUrl
+    });
+    if (options.json) {
+      console.log(
+        JSON.stringify(
+          {
+            chainId: readOnlyOptions.chainId,
+            sort,
+            count: tokens.length,
+            tokens: tokens.map((t) => ({
+              ...t,
+              url: tokenUrl(readOnlyOptions.chainId, t.address)
+            }))
+          },
+          null,
+          2
+        )
+      );
+      return;
+    }
+    if (tokens.length === 0) {
+      console.log(chalk4.yellow("No tokens found."));
+      return;
+    }
+    console.log(
+      chalk4.white(
+        `Top ${tokens.length} tokens by ${sort} on chain ${readOnlyOptions.chainId}:`
+      )
+    );
+    console.log();
+    tokens.forEach((t, i) => {
+      const rank = chalk4.dim(`#${(i + 1).toString().padStart(2, " ")}`);
+      const symbol = chalk4.cyan((t.symbol || "?").padEnd(10, " "));
+      const upvotes = chalk4.white(`${t.upvotes} upvotes`.padEnd(18, " "));
+      const fdv = chalk4.dim(`FDV ${formatNumber(t.fdv)}`.padEnd(14, " "));
+      const price = chalk4.dim(`${formatPrice(t.priceInUsdc)}`.padEnd(14, " "));
+      console.log(`${rank}  ${symbol} ${upvotes} ${fdv} ${price} ${t.address}`);
+    });
+  } catch (error) {
+    exitWithError(
+      `Failed to fetch token rankings: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+function registerRankingsCommand(parent, commandName = "rankings") {
+  parent.command(commandName).description(
+    "List tokens ranked by upvote activity (trending / recent / top)"
+  ).option(
+    "--sort <sort>",
+    `Ranking strategy: ${VALID_SORTS.join(" | ")} (default: trending)`,
+    "trending"
+  ).option(
+    "--limit <n>",
+    "Number of tokens to return (1-100, default: 50)",
+    (v) => parseInt(v, 10),
+    50
+  ).option(
+    "--scan-window <n>",
+    "Messages to scan per contract (default: 150)",
+    (v) => parseInt(v, 10)
+  ).option(
+    "--min-upvotes <n>",
+    "Floor for two-tier filter (default: 500)",
+    (v) => parseInt(v, 10)
+  ).option(
+    "--min-market-cap <n>",
+    "FDV floor in USDC (default: 40000)",
+    (v) => parseInt(v, 10)
+  ).option(
+    "--recency-hours <n>",
+    "Drop below-floor tokens with no upvote within N hours (default: 48)",
+    (v) => parseInt(v, 10)
+  ).option(
+    "--chain-id <id>",
+    "Chain ID (default: 8453 for Base)",
+    (v) => parseInt(v, 10)
+  ).option("--rpc-url <url>", "Custom RPC URL").option("--json", "Output in JSON format").action(async (options) => {
+    await executeRankings(options);
+  });
+}
 
 // src/commands/upvote/index.ts
 function registerUpvoteCommand(program2) {
@@ -7880,6 +8437,7 @@ function registerUpvoteCommand(program2) {
   registerGetUpvotesCommand(upvoteCommand);
   registerUpvoteUserCommand(upvoteCommand);
   registerGetUserUpvotesCommand(upvoteCommand);
+  registerRankingsCommand(upvoteCommand);
 }
 var VALID_RUN_MODES = ["auto", "feeds", "chats"];
 function addAuthOptions(cmd) {