@net-protocol/cli 0.1.28 → 0.1.30

package/dist/cli/index.mjs

@@ -7,7 +7,7 @@ import chalk4 from 'chalk';
 import * as fs6 from 'fs';
 import { readFileSync, existsSync, mkdirSync, writeFileSync } from 'fs';
 import { OPTIMAL_CHUNK_SIZE, 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 { stringToHex, createWalletClient, http, hexToString, parseEther, encodeFunctionData, publicActions, defineChain, createPublicClient } from 'viem';
 import { privateKeyToAccount } from 'viem/accounts';
 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';
@@ -21,6 +21,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 } from '@net-protocol/score';
 
 var DEFAULT_CHAIN_ID = 8453;
 function getRequiredChainId(optionValue) {
@@ -3243,7 +3244,7 @@ ${available}`
     const buffer = fs6.readFileSync(filePath);
     if (buffer.length > MAX_CSS_SIZE) {
       exitWithError(
-        `File too large: ${buffer.length} bytes exceeds maximum of ${MAX_CSS_SIZE} bytes (10KB).`
+        `File too large: ${buffer.length} bytes exceeds maximum of ${MAX_CSS_SIZE} bytes (15KB).`
       );
     }
     cssContent = buffer.toString("utf-8");
@@ -3252,7 +3253,7 @@ ${available}`
     const contentSize = Buffer.byteLength(cssContent, "utf-8");
     if (contentSize > MAX_CSS_SIZE) {
       exitWithError(
-        `Content too large: ${contentSize} bytes exceeds maximum of ${MAX_CSS_SIZE} bytes (10KB).`
+        `Content too large: ${contentSize} bytes exceeds maximum of ${MAX_CSS_SIZE} bytes (15KB).`
       );
     }
   }
@@ -6914,6 +6915,226 @@ function registerFeedCommand(program2) {
   registerFeedHistoryCommand(feedCommand);
   registerAgentRegisterCommand(feedCommand);
 }
+async function executeUpvoteToken(options) {
+  const count = parseInt(options.count, 10);
+  if (isNaN(count) || count <= 0) {
+    exitWithError("Count must be a positive integer");
+    return;
+  }
+  const tokenAddress = options.tokenAddress;
+  if (!tokenAddress.startsWith("0x") || tokenAddress.length !== 42) {
+    exitWithError(
+      "Invalid token address format (must be 0x-prefixed, 42 characters)"
+    );
+    return;
+  }
+  const readOnlyOptions = parseReadOnlyOptionsWithDefault({
+    chainId: options.chainId,
+    rpcUrl: options.rpcUrl
+  });
+  const rpcUrls = getChainRpcUrls({
+    chainId: readOnlyOptions.chainId,
+    rpcUrl: readOnlyOptions.rpcUrl
+  });
+  const publicClient = createPublicClient({
+    transport: http(rpcUrls[0])
+  });
+  console.log(chalk4.blue("Discovering Uniswap pool for token..."));
+  let poolResult;
+  try {
+    poolResult = await discoverTokenPool({
+      publicClient,
+      tokenAddress
+    });
+  } catch (error) {
+    exitWithError(
+      `Failed to discover token pool: ${error instanceof Error ? error.message : String(error)}`
+    );
+    return;
+  }
+  let strategyAddress;
+  let storedContext;
+  if (!poolResult || !poolResult.poolKey) {
+    strategyAddress = PURE_ALPHA_STRATEGY.address;
+    storedContext = "0x";
+    console.log(chalk4.yellow("No pool found \u2014 using Pure Alpha strategy"));
+  } else if (options.splitType === "50/50") {
+    strategyAddress = UNIV234_POOLS_STRATEGY.address;
+    storedContext = encodePoolKey(poolResult.poolKey);
+    console.log(
+      chalk4.green(
+        `Pool found (fee: ${poolResult.fee}) \u2014 using 50/50 Pools strategy`
+      )
+    );
+  } else {
+    strategyAddress = DYNAMIC_SPLIT_STRATEGY.address;
+    storedContext = encodePoolKey(poolResult.poolKey);
+    console.log(
+      chalk4.green(
+        `Pool found (fee: ${poolResult.fee}) \u2014 using Dynamic Split strategy`
+      )
+    );
+  }
+  const scoreKey = getTokenScoreKey(tokenAddress);
+  const value = parseEther((count * UPVOTE_PRICE_ETH).toString());
+  const txConfig = {
+    to: UPVOTE_APP.address,
+    abi: UPVOTE_APP.abi,
+    functionName: "upvote",
+    args: [strategyAddress, scoreKey, count, storedContext, "0x"],
+    value
+  };
+  if (options.encodeOnly) {
+    const encoded = encodeTransaction(txConfig, readOnlyOptions.chainId);
+    console.log(JSON.stringify(encoded, null, 2));
+    return;
+  }
+  const commonOptions = parseCommonOptionsWithDefault(
+    {
+      privateKey: options.privateKey,
+      chainId: options.chainId,
+      rpcUrl: options.rpcUrl
+    },
+    true
+  );
+  const walletClient = createWallet(
+    commonOptions.privateKey,
+    commonOptions.chainId,
+    commonOptions.rpcUrl
+  );
+  console.log(
+    chalk4.blue(`Submitting ${count} upvote(s) for ${tokenAddress}...`)
+  );
+  try {
+    const hash = await executeTransaction(walletClient, txConfig);
+    console.log(chalk4.green(`Upvote submitted successfully!`));
+    console.log(chalk4.white(`  Transaction: ${hash}`));
+    console.log(chalk4.white(`  Token: ${tokenAddress}`));
+    console.log(chalk4.white(`  Count: ${count}`));
+    console.log(
+      chalk4.white(`  Value: ${(count * UPVOTE_PRICE_ETH).toFixed(6)} ETH`)
+    );
+  } catch (error) {
+    exitWithError(
+      `Failed to submit upvote: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+function registerUpvoteTokenCommand(parent, commandName = "token") {
+  parent.command(commandName).description("Upvote a token on Net Protocol").requiredOption(
+    "--token-address <address>",
+    "Token contract address to upvote"
+  ).requiredOption("--count <n>", "Number of upvotes").option(
+    "--split-type <type>",
+    'Strategy split type: "dynamic" (default) or "50/50"'
+  ).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 (options) => {
+    await executeUpvoteToken(options);
+  });
+}
+function getStrategyName(address) {
+  const lower = address.toLowerCase();
+  if (lower === PURE_ALPHA_STRATEGY.address.toLowerCase()) return "Pure Alpha";
+  if (lower === UNIV234_POOLS_STRATEGY.address.toLowerCase())
+    return "50/50 Pools";
+  if (lower === DYNAMIC_SPLIT_STRATEGY.address.toLowerCase())
+    return "Dynamic Split";
+  return address;
+}
+async function executeGetUpvotes(options) {
+  const tokenAddress = options.tokenAddress;
+  if (!tokenAddress.startsWith("0x") || tokenAddress.length !== 42) {
+    exitWithError(
+      "Invalid token address format (must be 0x-prefixed, 42 characters)"
+    );
+    return;
+  }
+  const readOnlyOptions = parseReadOnlyOptionsWithDefault({
+    chainId: options.chainId,
+    rpcUrl: options.rpcUrl
+  });
+  const client = new ScoreClient({
+    chainId: readOnlyOptions.chainId,
+    overrides: readOnlyOptions.rpcUrl ? { rpcUrls: [readOnlyOptions.rpcUrl] } : void 0
+  });
+  const scoreKey = getTokenScoreKey(tokenAddress);
+  try {
+    const [totalCounts, ...perStrategyCounts] = await Promise.all([
+      client.getUpvotesWithLegacy({
+        scoreKeys: [scoreKey],
+        strategies: ALL_STRATEGY_ADDRESSES
+      }),
+      ...ALL_STRATEGY_ADDRESSES.map(
+        (strategy) => client.getStrategyKeyScores({
+          strategy,
+          scoreKeys: [scoreKey]
+        })
+      )
+    ]);
+    const total = totalCounts[0] ?? 0;
+    const strategyCounts = ALL_STRATEGY_ADDRESSES.map((addr, i) => ({
+      strategy: getStrategyName(addr),
+      address: addr,
+      count: perStrategyCounts[i]?.[0] ?? 0
+    }));
+    if (options.json) {
+      console.log(
+        JSON.stringify(
+          {
+            tokenAddress,
+            scoreKey,
+            total,
+            strategies: strategyCounts.map((s) => ({
+              name: s.strategy,
+              address: s.address,
+              count: s.count
+            }))
+          },
+          null,
+          2
+        )
+      );
+    } else {
+      console.log(chalk4.white(`Upvotes for ${tokenAddress}:`));
+      console.log(chalk4.cyan(`  Total: ${total}`));
+      console.log();
+      for (const s of strategyCounts) {
+        if (s.count > 0) {
+          console.log(chalk4.white(`  ${s.strategy}: ${s.count}`));
+        }
+      }
+      if (total === 0) {
+        console.log(chalk4.yellow("  No upvotes found"));
+      }
+    }
+  } catch (error) {
+    exitWithError(
+      `Failed to fetch upvotes: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+function registerGetUpvotesCommand(parent, commandName = "info") {
+  parent.command(commandName).description("Get upvote counts for a token").requiredOption("--token-address <address>", "Token contract address").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 executeGetUpvotes(options);
+  });
+}
+
+// src/commands/upvote/index.ts
+function registerUpvoteCommand(program2) {
+  const upvoteCommand = program2.command("upvote").description("Upvote tokens on Net Protocol");
+  registerUpvoteTokenCommand(upvoteCommand);
+  registerGetUpvotesCommand(upvoteCommand);
+}
 var CACHE_DIR = join(homedir(), ".netp");
 var CACHE_FILE = join(CACHE_DIR, "update-check.json");
 var CHECK_INTERVAL_MS = 4 * 60 * 60 * 1e3;
@@ -7013,6 +7234,7 @@ registerTokenCommand(program);
 registerProfileCommand(program);
 registerBazaarCommand(program);
 registerFeedCommand(program);
+registerUpvoteCommand(program);
 program.command("update").description("Update netp to the latest version").action(async () => {
   const { execSync } = await import('child_process');
   console.log("Updating @net-protocol/cli...");