@net-protocol/cli 0.1.33 → 0.1.35

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, createPublicClient } from 'viem';
+import { stringToHex, createWalletClient, http, hexToString, parseEther, encodeFunctionData, publicActions, concat, defineChain, createPublicClient, formatEther } from 'viem';
 import { privateKeyToAccount } from 'viem/accounts';
 import { getNetContract, getChainName, getPublicClient, getChainRpcUrls, getBaseDataSuffix, 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,7 +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';
+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';
 
 var DEFAULT_CHAIN_ID = 8453;
 function getRequiredChainId(optionValue) {
@@ -1236,9 +1236,11 @@ function encodeTransaction(config, chainId) {
     functionName: config.functionName,
     args: config.args
   });
+  const suffix = getBaseDataSuffix(chainId);
+  const data = suffix ? concat([calldata, suffix]) : calldata;
   return {
     to: config.to,
-    data: calldata,
+    data,
     chainId,
     value: config.value?.toString() ?? "0"
   };
@@ -2062,20 +2064,20 @@ async function executeEncodeOnly2(options) {
     },
     saltResult.salt
   );
-  const calldata = encodeFunctionData({
-    abi: txConfig.abi,
-    functionName: txConfig.functionName,
-    args: txConfig.args
-  });
+  const encoded = encodeTransaction(
+    {
+      to: txConfig.address,
+      abi: txConfig.abi,
+      functionName: txConfig.functionName,
+      args: txConfig.args,
+      value: txConfig.value
+    },
+    readOnlyOptions.chainId
+  );
   const result = {
     predictedAddress: saltResult.predictedAddress,
     salt: saltResult.salt,
-    transaction: {
-      to: txConfig.address,
-      data: calldata,
-      chainId: readOnlyOptions.chainId,
-      value: txConfig.value?.toString() ?? "0"
-    },
+    transaction: encoded,
     config: {
       name: options.name,
       symbol: options.symbol,
@@ -7153,12 +7155,174 @@ function registerGetUpvotesCommand(parent, commandName = "info") {
     await executeGetUpvotes(options);
   });
 }
+async function executeUpvoteUser(options) {
+  const count = parseInt(options.count, 10);
+  if (isNaN(count) || count <= 0) {
+    exitWithError("Count must be a positive integer");
+    return;
+  }
+  const userAddress = options.address;
+  if (!userAddress.startsWith("0x") || userAddress.length !== 42) {
+    exitWithError(
+      "Invalid address format (must be 0x-prefixed, 42 characters)"
+    );
+    return;
+  }
+  const token = options.token ?? NULL_ADDRESS$1;
+  const feeTier = options.feeTier ? parseInt(options.feeTier, 10) : 0;
+  const readOnlyOptions = parseReadOnlyOptionsWithDefault({
+    chainId: options.chainId,
+    rpcUrl: options.rpcUrl
+  });
+  const client = new UserUpvoteClient({
+    chainId: readOnlyOptions.chainId,
+    overrides: readOnlyOptions.rpcUrl ? { rpcUrls: [readOnlyOptions.rpcUrl] } : void 0
+  });
+  let upvotePrice;
+  try {
+    upvotePrice = await client.getUpvotePrice();
+  } catch (error) {
+    exitWithError(
+      `Failed to fetch upvote price: ${error instanceof Error ? error.message : String(error)}`
+    );
+    return;
+  }
+  const totalCost = calculateUpvoteCost(count, upvotePrice);
+  if (options.encodeOnly) {
+    const txConfig = {
+      to: USER_UPVOTE_CONTRACT.address,
+      abi: USER_UPVOTE_CONTRACT.abi,
+      functionName: "upvoteUser",
+      args: [userAddress, token, BigInt(count), BigInt(feeTier)],
+      value: totalCost
+    };
+    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} profile upvote(s) for ${userAddress}...`)
+  );
+  try {
+    const hash = await client.upvoteUser({
+      walletClient,
+      userToUpvote: userAddress,
+      token,
+      numUpvotes: count,
+      feeTier,
+      value: totalCost
+    });
+    console.log(chalk4.green("Profile upvote submitted successfully!"));
+    console.log(chalk4.white(`  Transaction: ${hash}`));
+    console.log(chalk4.white(`  User: ${userAddress}`));
+    console.log(chalk4.white(`  Count: ${count}`));
+    console.log(chalk4.white(`  Value: ${formatEther(totalCost)} ETH`));
+    if (token !== NULL_ADDRESS$1) {
+      console.log(chalk4.white(`  Token: ${token}`));
+    }
+  } catch (error) {
+    exitWithError(
+      `Failed to submit profile upvote: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+function registerUpvoteUserCommand(parent, commandName = "user") {
+  parent.command(commandName).description("Upvote a user's profile on Net Protocol").requiredOption("--address <address>", "User address to upvote").requiredOption("--count <n>", "Number of upvotes").option("--token <address>", "Token address (default: null address)").option("--fee-tier <tier>", "Fee tier (default: 0)").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 executeUpvoteUser(options);
+  });
+}
+async function executeGetUserUpvotes(options) {
+  const userAddress = options.address;
+  if (!userAddress.startsWith("0x") || userAddress.length !== 42) {
+    exitWithError(
+      "Invalid address format (must be 0x-prefixed, 42 characters)"
+    );
+    return;
+  }
+  const readOnlyOptions = parseReadOnlyOptionsWithDefault({
+    chainId: options.chainId,
+    rpcUrl: options.rpcUrl
+  });
+  const client = new UserUpvoteClient({
+    chainId: readOnlyOptions.chainId,
+    overrides: readOnlyOptions.rpcUrl ? { rpcUrls: [readOnlyOptions.rpcUrl] } : void 0
+  });
+  try {
+    const [given, received, upvotePrice] = await Promise.all([
+      client.getUserUpvotesGiven({
+        user: userAddress
+      }),
+      client.getUserUpvotesReceived({
+        user: userAddress
+      }),
+      client.getUpvotePrice()
+    ]);
+    if (options.json) {
+      console.log(
+        JSON.stringify(
+          {
+            address: userAddress,
+            chainId: readOnlyOptions.chainId,
+            upvotesGiven: Number(given),
+            upvotesReceived: Number(received),
+            upvotePriceWei: upvotePrice.toString(),
+            upvotePriceEth: formatEther(upvotePrice)
+          },
+          null,
+          2
+        )
+      );
+    } else {
+      console.log(chalk4.white(`Profile upvotes for ${userAddress}:`));
+      console.log(chalk4.cyan(`  Upvotes Given:    ${given}`));
+      console.log(chalk4.cyan(`  Upvotes Received: ${received}`));
+      console.log(
+        chalk4.white(`  Upvote Price:     ${formatEther(upvotePrice)} ETH`)
+      );
+    }
+  } catch (error) {
+    exitWithError(
+      `Failed to fetch user upvotes: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+function registerGetUserUpvotesCommand(parent, commandName = "user-info") {
+  parent.command(commandName).description("Get profile upvote stats for a user").requiredOption("--address <address>", "User address to look up").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 executeGetUserUpvotes(options);
+  });
+}
 
 // src/commands/upvote/index.ts
 function registerUpvoteCommand(program2) {
-  const upvoteCommand = program2.command("upvote").description("Upvote tokens on Net Protocol");
+  const upvoteCommand = program2.command("upvote").description("Upvote tokens and users on Net Protocol");
   registerUpvoteTokenCommand(upvoteCommand);
   registerGetUpvotesCommand(upvoteCommand);
+  registerUpvoteUserCommand(upvoteCommand);
+  registerGetUserUpvotesCommand(upvoteCommand);
 }
 var CACHE_DIR = join(homedir(), ".netp");
 var CACHE_FILE = join(CACHE_DIR, "update-check.json");