@net-protocol/cli 0.1.0 → 0.1.1

package/dist/cli/index.mjs

@@ -1,19 +1,36 @@
 #!/usr/bin/env node
 import 'dotenv/config';
 import { Command } from 'commander';
-import chalk2 from 'chalk';
+import chalk4 from 'chalk';
+import * as fs from 'fs';
 import { readFileSync } from 'fs';
-import { detectFileTypeFromBase64, base64ToDataUri, StorageClient, shouldSuggestXmlStorage, getStorageKeyBytes, encodeStorageKeyForUrl, STORAGE_CONTRACT, CHUNKED_STORAGE_CONTRACT } from '@net-protocol/storage';
-import { stringToHex, createWalletClient, http, hexToString, defineChain } from 'viem';
+import { StorageClient, detectFileTypeFromBase64, base64ToDataUri, shouldSuggestXmlStorage, getStorageKeyBytes, encodeStorageKeyForUrl, STORAGE_CONTRACT, CHUNKED_STORAGE_CONTRACT } from '@net-protocol/storage';
+import { stringToHex, createWalletClient, http, hexToString, parseEther, encodeFunctionData, defineChain } from 'viem';
 import { privateKeyToAccount } from 'viem/accounts';
-import { getPublicClient, getChainRpcUrls } from '@net-protocol/core';
+import { getNetContract, getChainName, getPublicClient, getChainRpcUrls, NetClient } from '@net-protocol/core';
 import { createRelayX402Client, createRelaySession, checkBackendWalletBalance, fundBackendWallet, batchTransactions, submitTransactionsViaRelay, waitForConfirmations, retryFailedTransactions as retryFailedTransactions$1 } from '@net-protocol/relay';
+import { isNetrSupportedChain, NetrClient } from '@net-protocol/netr';
 
+function getRequiredChainId(optionValue) {
+  const chainId = optionValue || (process.env.NET_CHAIN_ID ? parseInt(process.env.NET_CHAIN_ID, 10) : void 0);
+  if (!chainId) {
+    console.error(
+      chalk4.red(
+        "Error: Chain ID is required. Provide via --chain-id flag or NET_CHAIN_ID environment variable"
+      )
+    );
+    process.exit(1);
+  }
+  return chainId;
+}
+function getRpcUrl(optionValue) {
+  return optionValue || process.env.NET_RPC_URL;
+}
 function parseCommonOptions(options) {
   const privateKey = options.privateKey || process.env.NET_PRIVATE_KEY || process.env.PRIVATE_KEY;
   if (!privateKey) {
     console.error(
-      chalk2.red(
+      chalk4.red(
         "Error: Private key is required. Provide via --private-key flag or NET_PRIVATE_KEY/PRIVATE_KEY environment variable"
       )
     );
@@ -21,7 +38,7 @@ function parseCommonOptions(options) {
   }
   if (!privateKey.startsWith("0x") || privateKey.length !== 66) {
     console.error(
-      chalk2.red(
+      chalk4.red(
         "Error: Invalid private key format (must be 0x-prefixed, 66 characters)"
       )
     );
@@ -29,25 +46,21 @@ function parseCommonOptions(options) {
   }
   if (options.privateKey) {
     console.warn(
-      chalk2.yellow(
-        "\u26A0\uFE0F  Warning: Private key provided via command line. Consider using NET_PRIVATE_KEY environment variable instead."
+      chalk4.yellow(
+        "Warning: Private key provided via command line. Consider using NET_PRIVATE_KEY environment variable instead."
       )
     );
   }
-  const chainId = options.chainId || (process.env.NET_CHAIN_ID ? parseInt(process.env.NET_CHAIN_ID, 10) : void 0);
-  if (!chainId) {
-    console.error(
-      chalk2.red(
-        "Error: Chain ID is required. Provide via --chain-id flag or NET_CHAIN_ID environment variable"
-      )
-    );
-    process.exit(1);
-  }
-  const rpcUrl = options.rpcUrl || process.env.NET_RPC_URL;
   return {
     privateKey,
-    chainId,
-    rpcUrl
+    chainId: getRequiredChainId(options.chainId),
+    rpcUrl: getRpcUrl(options.rpcUrl)
+  };
+}
+function parseReadOnlyOptions(options) {
+  return {
+    chainId: getRequiredChainId(options.chainId),
+    rpcUrl: getRpcUrl(options.rpcUrl)
   };
 }
 async function checkNormalStorageExists(params) {
@@ -1019,6 +1032,202 @@ async function previewFile(options) {
     };
   }
 }
+function formatMessage(message, index) {
+  const timestamp = new Date(Number(message.timestamp) * 1e3).toISOString();
+  const lines = [
+    chalk4.cyan(`[${index}]`) + ` ${chalk4.gray(timestamp)}`,
+    `  ${chalk4.white("Sender:")} ${message.sender}`,
+    `  ${chalk4.white("App:")} ${message.app}`
+  ];
+  if (message.topic) {
+    lines.push(`  ${chalk4.white("Topic:")} ${message.topic}`);
+  }
+  lines.push(`  ${chalk4.white("Text:")} ${message.text}`);
+  if (message.data && message.data !== "0x") {
+    lines.push(`  ${chalk4.white("Data:")} ${message.data}`);
+  }
+  return lines.join("\n");
+}
+function messageToJson(message, index) {
+  return {
+    index,
+    sender: message.sender,
+    app: message.app,
+    timestamp: Number(message.timestamp),
+    text: message.text,
+    topic: message.topic,
+    data: message.data
+  };
+}
+function printMessages(messages, startIndex, json) {
+  if (json) {
+    const output = messages.map((msg, i) => messageToJson(msg, startIndex + i));
+    console.log(JSON.stringify(output, null, 2));
+  } else {
+    if (messages.length === 0) {
+      console.log(chalk4.yellow("No messages found"));
+      return;
+    }
+    messages.forEach((msg, i) => {
+      console.log(formatMessage(msg, startIndex + i));
+      if (i < messages.length - 1) {
+        console.log();
+      }
+    });
+  }
+}
+function printCount(count, label, json) {
+  if (json) {
+    console.log(JSON.stringify({ count }, null, 2));
+  } else {
+    console.log(`${chalk4.white(label)} ${chalk4.cyan(count)}`);
+  }
+}
+function exitWithError(message) {
+  console.error(chalk4.red(`Error: ${message}`));
+  process.exit(1);
+}
+
+// src/commands/storage/core/read.ts
+async function executeStorageRead(options) {
+  const readOnlyOptions = parseReadOnlyOptions({
+    chainId: options.chainId,
+    rpcUrl: options.rpcUrl
+  });
+  const client = new StorageClient({
+    chainId: readOnlyOptions.chainId,
+    overrides: options.rpcUrl ? { rpcUrls: [options.rpcUrl] } : void 0
+  });
+  try {
+    const result = await client.readStorageData({
+      key: options.key,
+      operator: options.operator,
+      index: options.index
+    });
+    if (options.json) {
+      const output = {
+        key: options.key,
+        operator: options.operator,
+        chainId: readOnlyOptions.chainId,
+        text: result.text,
+        data: options.raw ? result.data : result.data,
+        isXml: result.isXml,
+        ...options.index !== void 0 && { index: options.index }
+      };
+      console.log(JSON.stringify(output, null, 2));
+      return;
+    }
+    console.log(chalk4.white.bold("\nStorage Value:\n"));
+    console.log(`  ${chalk4.cyan("Key:")} ${options.key}`);
+    console.log(`  ${chalk4.cyan("Operator:")} ${options.operator}`);
+    console.log(`  ${chalk4.cyan("Chain ID:")} ${readOnlyOptions.chainId}`);
+    if (options.index !== void 0) {
+      console.log(`  ${chalk4.cyan("Index:")} ${options.index}`);
+    }
+    console.log(`  ${chalk4.cyan("Text:")} ${result.text || "(empty)"}`);
+    console.log(`  ${chalk4.cyan("Is XML:")} ${result.isXml ? "Yes" : "No"}`);
+    const dataPreview = result.data.length > 500 ? result.data.substring(0, 500) + "... (truncated)" : result.data;
+    console.log(`  ${chalk4.cyan("Data:")}`);
+    if (result.data) {
+      console.log(chalk4.gray(`    ${dataPreview.split("\n").join("\n    ")}`));
+    } else {
+      console.log(chalk4.gray("    (empty)"));
+    }
+    console.log();
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    if (errorMessage === "StoredDataNotFound") {
+      if (options.json) {
+        console.log(
+          JSON.stringify(
+            {
+              key: options.key,
+              operator: options.operator,
+              chainId: readOnlyOptions.chainId,
+              error: "Not found"
+            },
+            null,
+            2
+          )
+        );
+        process.exit(1);
+      }
+      exitWithError(
+        `No data found for key "${options.key}" and operator "${options.operator}"`
+      );
+    }
+    exitWithError(`Failed to read storage: ${errorMessage}`);
+  }
+}
+function encodeTransaction(config, chainId) {
+  const calldata = encodeFunctionData({
+    abi: config.abi,
+    functionName: config.functionName,
+    args: config.args
+  });
+  return {
+    to: config.to,
+    data: calldata,
+    chainId,
+    value: config.value?.toString() ?? "0"
+  };
+}
+
+// src/commands/storage/core/encode.ts
+var XML_STORAGE_THRESHOLD = 20 * 1024;
+async function encodeStorageUpload(options) {
+  const readOnlyOptions = parseReadOnlyOptions({
+    chainId: options.chainId,
+    rpcUrl: options.rpcUrl
+  });
+  let operatorAddress;
+  if (options.privateKey) {
+    const account = privateKeyToAccount(options.privateKey);
+    operatorAddress = account.address;
+  } else {
+    operatorAddress = "0x0000000000000000000000000000000000000000";
+  }
+  const fileContent = fs.readFileSync(options.filePath, "utf-8");
+  const fileSize = Buffer.byteLength(fileContent, "utf-8");
+  const client = new StorageClient({
+    chainId: readOnlyOptions.chainId
+  });
+  const useXmlStorage = fileSize > XML_STORAGE_THRESHOLD;
+  if (useXmlStorage) {
+    const { transactionConfigs, topLevelHash, metadata } = client.prepareXmlStorage({
+      data: fileContent,
+      operatorAddress,
+      storageKey: options.storageKey,
+      filename: options.text
+    });
+    const encodedTransactions = transactionConfigs.map(
+      (config) => encodeTransaction(config, readOnlyOptions.chainId)
+    );
+    return {
+      storageKey: options.storageKey,
+      storageType: "xml",
+      operatorAddress,
+      transactions: encodedTransactions,
+      topLevelHash
+    };
+  } else {
+    const config = client.preparePut({
+      key: options.storageKey,
+      text: options.text,
+      value: fileContent
+    });
+    const encodedTransaction = encodeTransaction(
+      config,
+      readOnlyOptions.chainId
+    );
+    return {
+      storageKey: options.storageKey,
+      storageType: "normal",
+      operatorAddress,
+      transactions: [encodedTransaction]
+    };
+  }
+}
 
 // src/commands/storage/index.ts
 function registerStorageCommand(program2) {
@@ -1033,7 +1242,32 @@ function registerStorageCommand(program2) {
   ).option(
     "--rpc-url <url>",
     "Custom RPC URL (can also be set via NET_RPC_URL env var)"
+  ).option(
+    "--encode-only",
+    "Output transaction data as JSON instead of executing"
   ).action(async (options) => {
+    if (options.encodeOnly) {
+      try {
+        const result = await encodeStorageUpload({
+          filePath: options.file,
+          storageKey: options.key,
+          text: options.text,
+          privateKey: options.privateKey,
+          chainId: options.chainId,
+          rpcUrl: options.rpcUrl
+        });
+        console.log(JSON.stringify(result, null, 2));
+        process.exit(0);
+      } catch (error) {
+        console.error(
+          chalk4.red(
+            `Encode failed: ${error instanceof Error ? error.message : String(error)}`
+          )
+        );
+        process.exit(1);
+      }
+      return;
+    }
     const commonOptions = parseCommonOptions({
       privateKey: options.privateKey,
       chainId: options.chainId,
@@ -1048,7 +1282,7 @@ function registerStorageCommand(program2) {
       rpcUrl: commonOptions.rpcUrl
     };
     try {
-      console.log(chalk2.blue(`\u{1F4C1} Reading file: ${options.file}`));
+      console.log(chalk4.blue(`\u{1F4C1} Reading file: ${options.file}`));
       const result = await uploadFile(uploadOptions);
       const storageUrl = generateStorageUrl(
         result.operatorAddress,
@@ -1057,31 +1291,31 @@ function registerStorageCommand(program2) {
       );
       if (result.skipped && result.transactionsSent === 0) {
         console.log(
-          chalk2.green(
+          chalk4.green(
             `\u2713 All data already stored - skipping upload
   Storage Key: ${options.key}
   Skipped: ${result.transactionsSkipped} transaction(s)${storageUrl ? `
-  Storage URL: ${chalk2.cyan(storageUrl)}` : ""}`
+  Storage URL: ${chalk4.cyan(storageUrl)}` : ""}`
           )
         );
         process.exit(0);
       }
       if (result.success) {
         console.log(
-          chalk2.green(
+          chalk4.green(
             `\u2713 File uploaded successfully!
   Storage Key: ${options.key}
   Storage Type: ${result.storageType === "xml" ? "XML" : "Normal"}
   Transactions Sent: ${result.transactionsSent}
   Transactions Skipped: ${result.transactionsSkipped}
   Final Transaction Hash: ${result.finalHash || "N/A"}${storageUrl ? `
-  Storage URL: ${chalk2.cyan(storageUrl)}` : ""}`
+  Storage URL: ${chalk4.cyan(storageUrl)}` : ""}`
           )
         );
         process.exit(0);
       } else {
         console.error(
-          chalk2.red(
+          chalk4.red(
             `\u2717 Upload completed with errors
   Transactions Sent: ${result.transactionsSent}
   Transactions Skipped: ${result.transactionsSkipped}
@@ -1093,7 +1327,7 @@ function registerStorageCommand(program2) {
       }
     } catch (error) {
       console.error(
-        chalk2.red(
+        chalk4.red(
           `Upload failed: ${error instanceof Error ? error.message : String(error)}`
         )
       );
@@ -1125,54 +1359,54 @@ function registerStorageCommand(program2) {
       rpcUrl: commonOptions.rpcUrl
     };
     try {
-      console.log(chalk2.blue(`\u{1F4C1} Reading file: ${options.file}`));
+      console.log(chalk4.blue(`\u{1F4C1} Reading file: ${options.file}`));
       const result = await previewFile(previewOptions);
       const storageUrl = generateStorageUrl(
         result.operatorAddress,
         commonOptions.chainId,
         options.key
       );
-      console.log(chalk2.cyan("\n\u{1F4CA} Storage Preview:"));
-      console.log(`  Storage Key: ${chalk2.white(result.storageKey)}`);
+      console.log(chalk4.cyan("\n\u{1F4CA} Storage Preview:"));
+      console.log(`  Storage Key: ${chalk4.white(result.storageKey)}`);
       console.log(
-        `  Storage Type: ${chalk2.white(
+        `  Storage Type: ${chalk4.white(
           result.storageType === "xml" ? "XML" : "Normal"
         )}`
       );
-      console.log(`  Total Chunks: ${chalk2.white(result.totalChunks)}`);
+      console.log(`  Total Chunks: ${chalk4.white(result.totalChunks)}`);
       console.log(
-        `  Already Stored: ${chalk2.green(result.alreadyStoredChunks)}`
+        `  Already Stored: ${chalk4.green(result.alreadyStoredChunks)}`
       );
       console.log(
-        `  Need to Store: ${chalk2.yellow(result.needToStoreChunks)}`
+        `  Need to Store: ${chalk4.yellow(result.needToStoreChunks)}`
       );
       if (result.storageType === "xml" && result.metadataNeedsStorage) {
-        console.log(`  Metadata: ${chalk2.yellow("Needs Storage")}`);
+        console.log(`  Metadata: ${chalk4.yellow("Needs Storage")}`);
       } else if (result.storageType === "xml") {
-        console.log(`  Metadata: ${chalk2.green("Already Stored")}`);
+        console.log(`  Metadata: ${chalk4.green("Already Stored")}`);
       }
       console.log(
-        `  Total Transactions: ${chalk2.white(result.totalTransactions)}`
+        `  Total Transactions: ${chalk4.white(result.totalTransactions)}`
       );
       console.log(
-        `  Transactions to Send: ${chalk2.yellow(result.transactionsToSend)}`
+        `  Transactions to Send: ${chalk4.yellow(result.transactionsToSend)}`
       );
       console.log(
-        `  Transactions Skipped: ${chalk2.green(result.transactionsSkipped)}`
+        `  Transactions Skipped: ${chalk4.green(result.transactionsSkipped)}`
       );
       console.log(
-        `  Operator Address: ${chalk2.gray(result.operatorAddress)}`
+        `  Operator Address: ${chalk4.gray(result.operatorAddress)}`
       );
       if (storageUrl) {
-        console.log(`  Storage URL: ${chalk2.cyan(storageUrl)}`);
+        console.log(`  Storage URL: ${chalk4.cyan(storageUrl)}`);
       }
       if (result.needToStoreChunks === 0 && !result.metadataNeedsStorage) {
         console.log(
-          chalk2.green("\n\u2713 All data is already stored - no upload needed")
+          chalk4.green("\n\u2713 All data is already stored - no upload needed")
         );
       } else {
         console.log(
-          chalk2.yellow(
+          chalk4.yellow(
             `
 \u26A0 ${result.transactionsToSend} transaction(s) would be sent`
           )
@@ -1181,7 +1415,7 @@ function registerStorageCommand(program2) {
       process.exit(0);
     } catch (error) {
       console.error(
-        chalk2.red(
+        chalk4.red(
           `Preview failed: ${error instanceof Error ? error.message : String(error)}`
         )
       );
@@ -1213,7 +1447,7 @@ function registerStorageCommand(program2) {
     const secretKey = options.secretKey || process.env.X402_SECRET_KEY;
     if (!secretKey) {
       console.error(
-        chalk2.red(
+        chalk4.red(
           "Error: --secret-key is required or set X402_SECRET_KEY environment variable"
         )
       );
@@ -1230,11 +1464,11 @@ function registerStorageCommand(program2) {
       secretKey
     };
     try {
-      console.log(chalk2.blue(`\u{1F4C1} Reading file: ${options.file}`));
-      console.log(chalk2.blue(`\u{1F517} Using relay API: ${options.apiUrl}`));
+      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: privateKeyToAccount3 } = await import('viem/accounts');
-      const userAccount = privateKeyToAccount3(commonOptions.privateKey);
+      const { privateKeyToAccount: privateKeyToAccount6 } = await import('viem/accounts');
+      const userAccount = privateKeyToAccount6(commonOptions.privateKey);
       const storageUrl = generateStorageUrl(
         userAccount.address,
         commonOptions.chainId,
@@ -1242,7 +1476,7 @@ function registerStorageCommand(program2) {
       );
       if (result.success) {
         console.log(
-          chalk2.green(
+          chalk4.green(
             `\u2713 File uploaded successfully via relay!
   Storage Key: ${options.key}
   Top-Level Hash: ${result.topLevelHash}
@@ -1252,13 +1486,13 @@ function registerStorageCommand(program2) {
   Backend Wallet: ${result.backendWalletAddress}
   Chunk Transaction Hashes: ${result.chunkTransactionHashes.length > 0 ? result.chunkTransactionHashes.join(", ") : "None"}${result.metadataTransactionHash ? `
   Metadata Transaction Hash: ${result.metadataTransactionHash}` : ""}${storageUrl ? `
-  Storage URL: ${chalk2.cyan(storageUrl)}` : ""}`
+  Storage URL: ${chalk4.cyan(storageUrl)}` : ""}`
           )
         );
         process.exit(0);
       } else {
         console.error(
-          chalk2.red(
+          chalk4.red(
             `\u2717 Upload completed with errors
   Chunks Sent: ${result.chunksSent}
   Chunks Skipped: ${result.chunksSkipped}
@@ -1270,22 +1504,726 @@ function registerStorageCommand(program2) {
       }
     } catch (error) {
       console.error(
-        chalk2.red(
+        chalk4.red(
           `Upload via relay failed: ${error instanceof Error ? error.message : String(error)}`
         )
       );
       process.exit(1);
     }
   });
+  const readCommand = new Command("read").description("Read data from Net Storage").requiredOption("--key <key>", "Storage key to read").requiredOption("--operator <address>", "Operator address (wallet that stored the data)").option(
+    "--chain-id <id>",
+    "Chain ID. Can also be set via NET_CHAIN_ID env var",
+    (value) => parseInt(value, 10)
+  ).option(
+    "--rpc-url <url>",
+    "Custom RPC URL. Can also be set via NET_RPC_URL env var"
+  ).option(
+    "--index <n>",
+    "Historical version index (0 = oldest). Omit for latest.",
+    (value) => parseInt(value, 10)
+  ).option("--json", "Output in JSON format").option("--raw", "Output raw data without truncation (use with --json)").action(async (options) => {
+    await executeStorageRead({
+      key: options.key,
+      operator: options.operator,
+      chainId: options.chainId,
+      rpcUrl: options.rpcUrl,
+      index: options.index,
+      json: options.json,
+      raw: options.raw
+    });
+  });
   storageCommand.addCommand(uploadCommand);
   storageCommand.addCommand(previewCommand);
   storageCommand.addCommand(uploadRelayCommand);
+  storageCommand.addCommand(readCommand);
+}
+function createNetClient(options) {
+  return new NetClient({
+    chainId: options.chainId,
+    overrides: options.rpcUrl ? { rpcUrls: [options.rpcUrl] } : void 0
+  });
+}
+
+// src/commands/message/send.ts
+function prepareMessageConfig(client, options) {
+  return client.prepareSendMessage({
+    text: options.text,
+    topic: options.topic ?? "",
+    data: options.data
+  });
+}
+async function executeSend(options) {
+  if (options.encodeOnly) {
+    executeEncodeOnly(options);
+    return;
+  }
+  const commonOptions = parseCommonOptions({
+    privateKey: options.privateKey,
+    chainId: options.chainId,
+    rpcUrl: options.rpcUrl
+  });
+  const client = createNetClient(commonOptions);
+  const txConfig = prepareMessageConfig(client, options);
+  const account = privateKeyToAccount(commonOptions.privateKey);
+  const rpcUrls = getChainRpcUrls({
+    chainId: commonOptions.chainId,
+    rpcUrl: commonOptions.rpcUrl
+  });
+  const walletClient = createWalletClient({
+    account,
+    transport: http(rpcUrls[0])
+  });
+  console.log(chalk4.blue("Sending message..."));
+  try {
+    const hash = await walletClient.writeContract({
+      address: txConfig.to,
+      abi: txConfig.abi,
+      functionName: txConfig.functionName,
+      args: txConfig.args,
+      chain: null
+    });
+    const topicLine = options.topic ? `
+  Topic: ${options.topic}` : "";
+    console.log(
+      chalk4.green(
+        `Message sent successfully!
+  Transaction: ${hash}
+  Text: ${options.text}${topicLine}`
+      )
+    );
+  } catch (error) {
+    exitWithError(
+      `Failed to send message: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+function executeEncodeOnly(options) {
+  const readOnlyOptions = parseReadOnlyOptions({
+    chainId: options.chainId,
+    rpcUrl: options.rpcUrl
+  });
+  const client = new NetClient({ chainId: readOnlyOptions.chainId });
+  const txConfig = prepareMessageConfig(client, options);
+  const encoded = encodeTransaction(txConfig, readOnlyOptions.chainId);
+  console.log(JSON.stringify(encoded, null, 2));
+}
+function buildFilter(options) {
+  if (!options.app) {
+    return void 0;
+  }
+  return {
+    appAddress: options.app,
+    topic: options.topic,
+    maker: options.sender
+  };
+}
+function warnIgnoredFilters(options) {
+  if (options.app || !options.topic && !options.sender) {
+    return;
+  }
+  const ignored = [];
+  if (options.topic) ignored.push("--topic");
+  if (options.sender) ignored.push("--sender");
+  console.warn(
+    chalk4.yellow(
+      `Warning: ${ignored.join(" and ")} ignored because --app is required for filtering`
+    )
+  );
+}
+
+// src/commands/message/read.ts
+function printEmptyResult(message, json) {
+  if (json) {
+    console.log(JSON.stringify([], null, 2));
+  } else {
+    console.log(chalk4.yellow(message));
+  }
+}
+async function executeRead(options) {
+  const readOnlyOptions = parseReadOnlyOptions({
+    chainId: options.chainId,
+    rpcUrl: options.rpcUrl
+  });
+  const client = createNetClient(readOnlyOptions);
+  const filter = buildFilter(options);
+  const json = options.json ?? false;
+  warnIgnoredFilters(options);
+  try {
+    if (options.index !== void 0) {
+      const message = await client.getMessageAtIndex({
+        messageIndex: options.index,
+        appAddress: filter?.appAddress,
+        topic: filter?.topic,
+        maker: filter?.maker
+      });
+      if (!message) {
+        exitWithError(`No message found at index ${options.index}`);
+      }
+      printMessages([message], options.index, json);
+      return;
+    }
+    const count = await client.getMessageCount({ filter });
+    if (count === 0) {
+      printEmptyResult("No messages found", json);
+      return;
+    }
+    const hasExplicitRange = options.start !== void 0 || options.end !== void 0;
+    let startIndex;
+    let endIndex;
+    if (hasExplicitRange) {
+      startIndex = options.start ?? 0;
+      endIndex = options.end ?? count;
+    } else {
+      const limit = options.limit ?? 10;
+      startIndex = Math.max(0, count - limit);
+      endIndex = count;
+    }
+    startIndex = Math.max(0, startIndex);
+    endIndex = Math.min(endIndex, count);
+    if (startIndex >= endIndex) {
+      printEmptyResult("No messages in specified range", json);
+      return;
+    }
+    const messages = await client.getMessagesBatch({
+      filter,
+      startIndex,
+      endIndex
+    });
+    printMessages(messages, startIndex, json);
+  } catch (error) {
+    exitWithError(
+      `Failed to read messages: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+
+// src/commands/message/count.ts
+function buildCountLabel(filter) {
+  if (!filter) {
+    return "Total messages:";
+  }
+  const parts = [];
+  if (filter.appAddress) parts.push(`app=${filter.appAddress}`);
+  if (filter.topic) parts.push(`topic="${filter.topic}"`);
+  if (filter.maker) parts.push(`sender=${filter.maker}`);
+  return `Messages (${parts.join(", ")}):`;
+}
+async function executeCount(options) {
+  const readOnlyOptions = parseReadOnlyOptions({
+    chainId: options.chainId,
+    rpcUrl: options.rpcUrl
+  });
+  const client = createNetClient(readOnlyOptions);
+  const filter = buildFilter(options);
+  warnIgnoredFilters(options);
+  try {
+    const count = await client.getMessageCount({ filter });
+    printCount(count, buildCountLabel(filter), options.json ?? false);
+  } catch (error) {
+    exitWithError(
+      `Failed to get message count: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+
+// src/commands/message/index.ts
+function registerMessageCommand(program2) {
+  const messageCommand = program2.command("message").description("Message operations");
+  const sendCommand = new Command("send").description("Send a message to Net Protocol").requiredOption("--text <text>", "Message text").option("--topic <topic>", "Message topic", "").option("--data <hex>", "Additional hex data").option(
+    "--private-key <key>",
+    "Private key (0x-prefixed hex). Can also be set via NET_PRIVATE_KEY env var"
+  ).option(
+    "--chain-id <id>",
+    "Chain ID. Can also be set via NET_CHAIN_ID env var",
+    (value) => parseInt(value, 10)
+  ).option(
+    "--rpc-url <url>",
+    "Custom RPC URL. Can also be set via NET_RPC_URL env var"
+  ).option(
+    "--encode-only",
+    "Output transaction data as JSON instead of executing"
+  ).action(async (options) => {
+    await executeSend({
+      text: options.text,
+      topic: options.topic,
+      data: options.data,
+      privateKey: options.privateKey,
+      chainId: options.chainId,
+      rpcUrl: options.rpcUrl,
+      encodeOnly: options.encodeOnly
+    });
+  });
+  const readCommand = new Command("read").description("Read messages from Net Protocol").option("--app <address>", "Filter by app address").option("--topic <topic>", "Filter by topic").option("--sender <address>", "Filter by sender address").option(
+    "--start <n>",
+    "Start index (inclusive)",
+    (value) => parseInt(value, 10)
+  ).option(
+    "--end <n>",
+    "End index (exclusive)",
+    (value) => parseInt(value, 10)
+  ).option(
+    "--index <n>",
+    "Single message at index",
+    (value) => parseInt(value, 10)
+  ).option(
+    "--limit <n>",
+    "Number of latest messages (default: 10)",
+    (value) => parseInt(value, 10)
+  ).option(
+    "--chain-id <id>",
+    "Chain ID. Can also be set via NET_CHAIN_ID env var",
+    (value) => parseInt(value, 10)
+  ).option(
+    "--rpc-url <url>",
+    "Custom RPC URL. Can also be set via NET_RPC_URL env var"
+  ).option("--json", "Output in JSON format").action(async (options) => {
+    await executeRead({
+      app: options.app,
+      topic: options.topic,
+      sender: options.sender,
+      start: options.start,
+      end: options.end,
+      index: options.index,
+      limit: options.limit,
+      chainId: options.chainId,
+      rpcUrl: options.rpcUrl,
+      json: options.json
+    });
+  });
+  const countCommand = new Command("count").description("Get message count from Net Protocol").option("--app <address>", "Filter by app address").option("--topic <topic>", "Filter by topic").option("--sender <address>", "Filter by sender address").option(
+    "--chain-id <id>",
+    "Chain ID. Can also be set via NET_CHAIN_ID env var",
+    (value) => parseInt(value, 10)
+  ).option(
+    "--rpc-url <url>",
+    "Custom RPC URL. Can also be set via NET_RPC_URL env var"
+  ).option("--json", "Output in JSON format").action(async (options) => {
+    await executeCount({
+      app: options.app,
+      topic: options.topic,
+      sender: options.sender,
+      chainId: options.chainId,
+      rpcUrl: options.rpcUrl,
+      json: options.json
+    });
+  });
+  messageCommand.addCommand(sendCommand);
+  messageCommand.addCommand(readCommand);
+  messageCommand.addCommand(countCommand);
+}
+var SUPPORTED_CHAINS = [
+  { id: 8453, name: "Base", type: "mainnet" },
+  { id: 1, name: "Ethereum", type: "mainnet" },
+  { id: 666666666, name: "Degen", type: "mainnet" },
+  { id: 5112, name: "Ham", type: "mainnet" },
+  { id: 57073, name: "Ink", type: "mainnet" },
+  { id: 130, name: "Unichain", type: "mainnet" },
+  { id: 999, name: "HyperEVM", type: "mainnet" },
+  { id: 9745, name: "Plasma", type: "mainnet" },
+  { id: 143, name: "Monad", type: "mainnet" },
+  { id: 84532, name: "Base Sepolia", type: "testnet" },
+  { id: 11155111, name: "Sepolia", type: "testnet" }
+];
+function registerChainsCommand(program2) {
+  program2.command("chains").description("List supported chains").option("--json", "Output in JSON format").action((options) => {
+    if (options.json) {
+      console.log(JSON.stringify(SUPPORTED_CHAINS, null, 2));
+      return;
+    }
+    console.log(chalk4.white.bold("Supported Chains:\n"));
+    console.log(chalk4.cyan("Mainnets:"));
+    SUPPORTED_CHAINS.filter((c) => c.type === "mainnet").forEach((chain) => {
+      console.log(`  ${chalk4.white(chain.name)} ${chalk4.gray(`(${chain.id})`)}`);
+    });
+    console.log(chalk4.cyan("\nTestnets:"));
+    SUPPORTED_CHAINS.filter((c) => c.type === "testnet").forEach((chain) => {
+      console.log(`  ${chalk4.white(chain.name)} ${chalk4.gray(`(${chain.id})`)}`);
+    });
+  });
+}
+function registerInfoCommand(program2) {
+  program2.command("info").description("Show contract info and stats").option(
+    "--chain-id <id>",
+    "Chain ID. Can also be set via NET_CHAIN_ID env var",
+    (value) => parseInt(value, 10)
+  ).option(
+    "--rpc-url <url>",
+    "Custom RPC URL. Can also be set via NET_RPC_URL env var"
+  ).option("--json", "Output in JSON format").action(async (options) => {
+    const readOnlyOptions = parseReadOnlyOptions({
+      chainId: options.chainId,
+      rpcUrl: options.rpcUrl
+    });
+    try {
+      const client = createNetClient(readOnlyOptions);
+      const contract = getNetContract(readOnlyOptions.chainId);
+      const chainName = getChainName({ chainId: readOnlyOptions.chainId });
+      const totalMessages = await client.getMessageCount({});
+      const info = {
+        chain: {
+          id: readOnlyOptions.chainId,
+          name: chainName || "Unknown"
+        },
+        contract: {
+          address: contract.address
+        },
+        stats: {
+          totalMessages
+        }
+      };
+      if (options.json) {
+        console.log(JSON.stringify(info, null, 2));
+        return;
+      }
+      console.log(chalk4.white.bold("Net Protocol Info\n"));
+      console.log(chalk4.cyan("Chain:"));
+      console.log(`  Name: ${chalk4.white(info.chain.name)}`);
+      console.log(`  ID: ${chalk4.white(info.chain.id)}`);
+      console.log(chalk4.cyan("\nContract:"));
+      console.log(`  Address: ${chalk4.white(info.contract.address)}`);
+      console.log(chalk4.cyan("\nStats:"));
+      console.log(`  Total Messages: ${chalk4.white(info.stats.totalMessages)}`);
+    } catch (error) {
+      exitWithError(
+        `Failed to get info: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  });
+}
+async function executeEncodeOnly2(options) {
+  const readOnlyOptions = parseReadOnlyOptions({
+    chainId: options.chainId,
+    rpcUrl: options.rpcUrl
+  });
+  if (!isNetrSupportedChain(readOnlyOptions.chainId)) {
+    exitWithError(
+      `Chain ${readOnlyOptions.chainId} is not supported for token deployment`
+    );
+  }
+  let deployerAddress;
+  if (options.privateKey) {
+    const account = privateKeyToAccount(options.privateKey);
+    deployerAddress = account.address;
+  } else {
+    deployerAddress = "0x0000000000000000000000000000000000000000";
+  }
+  const client = new NetrClient({
+    chainId: readOnlyOptions.chainId,
+    overrides: options.rpcUrl ? { rpcUrls: [options.rpcUrl] } : void 0
+  });
+  const saltResult = await client.generateSalt({
+    name: options.name,
+    symbol: options.symbol,
+    image: options.image,
+    animation: options.animation,
+    deployer: deployerAddress,
+    fid: options.fid ? BigInt(options.fid) : void 0,
+    metadataAddress: options.metadataAddress,
+    extraStringData: options.extraStringData
+  });
+  if (!saltResult) {
+    exitWithError("Failed to generate salt for token deployment");
+    return;
+  }
+  const txConfig = client.buildDeployConfig(
+    {
+      name: options.name,
+      symbol: options.symbol,
+      image: options.image,
+      animation: options.animation,
+      deployer: deployerAddress,
+      fid: options.fid ? BigInt(options.fid) : void 0,
+      mintPrice: options.mintPrice ? BigInt(options.mintPrice) : void 0,
+      mintEndTimestamp: options.mintEndTimestamp ? BigInt(options.mintEndTimestamp) : void 0,
+      maxMintSupply: options.maxMintSupply ? BigInt(options.maxMintSupply) : void 0,
+      metadataAddress: options.metadataAddress,
+      extraStringData: options.extraStringData,
+      initialBuy: options.initialBuy ? parseEther(options.initialBuy) : void 0
+    },
+    saltResult.salt
+  );
+  const calldata = encodeFunctionData({
+    abi: txConfig.abi,
+    functionName: txConfig.functionName,
+    args: txConfig.args
+  });
+  const result = {
+    predictedAddress: saltResult.predictedAddress,
+    salt: saltResult.salt,
+    transaction: {
+      to: txConfig.address,
+      data: calldata,
+      chainId: readOnlyOptions.chainId,
+      value: txConfig.value?.toString() ?? "0"
+    },
+    config: {
+      name: options.name,
+      symbol: options.symbol,
+      image: options.image,
+      deployer: deployerAddress,
+      ...options.initialBuy && { initialBuy: options.initialBuy }
+    }
+  };
+  console.log(JSON.stringify(result, null, 2));
+}
+async function executeTokenDeploy(options) {
+  if (options.encodeOnly) {
+    await executeEncodeOnly2(options);
+    return;
+  }
+  const commonOptions = parseCommonOptions({
+    privateKey: options.privateKey,
+    chainId: options.chainId,
+    rpcUrl: options.rpcUrl
+  });
+  if (!isNetrSupportedChain(commonOptions.chainId)) {
+    exitWithError(
+      `Chain ${commonOptions.chainId} is not supported for token deployment. Supported: Base (8453), Plasma (9745), Monad (143), HyperEVM (999)`
+    );
+  }
+  const account = privateKeyToAccount(commonOptions.privateKey);
+  const client = new NetrClient({
+    chainId: commonOptions.chainId,
+    overrides: commonOptions.rpcUrl ? { rpcUrls: [commonOptions.rpcUrl] } : void 0
+  });
+  console.log(chalk4.blue("Generating salt and predicting token address..."));
+  const saltResult = await client.generateSalt({
+    name: options.name,
+    symbol: options.symbol,
+    image: options.image,
+    animation: options.animation,
+    deployer: account.address,
+    fid: options.fid ? BigInt(options.fid) : void 0,
+    metadataAddress: options.metadataAddress,
+    extraStringData: options.extraStringData
+  });
+  if (!saltResult) {
+    exitWithError("Failed to generate salt for token deployment");
+    return;
+  }
+  console.log(
+    chalk4.cyan(`Predicted token address: ${saltResult.predictedAddress}`)
+  );
+  const txConfig = client.buildDeployConfig(
+    {
+      name: options.name,
+      symbol: options.symbol,
+      image: options.image,
+      animation: options.animation,
+      deployer: account.address,
+      fid: options.fid ? BigInt(options.fid) : void 0,
+      mintPrice: options.mintPrice ? BigInt(options.mintPrice) : void 0,
+      mintEndTimestamp: options.mintEndTimestamp ? BigInt(options.mintEndTimestamp) : void 0,
+      maxMintSupply: options.maxMintSupply ? BigInt(options.maxMintSupply) : void 0,
+      metadataAddress: options.metadataAddress,
+      extraStringData: options.extraStringData,
+      initialBuy: options.initialBuy ? parseEther(options.initialBuy) : void 0
+    },
+    saltResult.salt
+  );
+  const rpcUrls = getChainRpcUrls({
+    chainId: commonOptions.chainId,
+    rpcUrl: commonOptions.rpcUrl
+  });
+  const walletClient = createWalletClient({
+    account,
+    transport: http(rpcUrls[0])
+  });
+  if (options.initialBuy) {
+    console.log(chalk4.blue(`Deploying token with ${options.initialBuy} ETH initial buy...`));
+  } else {
+    console.log(chalk4.blue("Deploying token..."));
+  }
+  try {
+    const calldata = encodeFunctionData({
+      abi: txConfig.abi,
+      functionName: txConfig.functionName,
+      args: txConfig.args
+    });
+    const hash = await walletClient.sendTransaction({
+      to: txConfig.address,
+      data: calldata,
+      chain: null,
+      value: txConfig.value
+    });
+    const initialBuyLine = options.initialBuy ? `
+  Initial Buy: ${options.initialBuy} ETH` : "";
+    console.log(
+      chalk4.green(
+        `Token deployed successfully!
+  Transaction: ${hash}
+  Token Address: ${saltResult.predictedAddress}
+  Name: ${options.name}
+  Symbol: ${options.symbol}${initialBuyLine}`
+      )
+    );
+  } catch (error) {
+    exitWithError(
+      `Failed to deploy token: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+async function executeTokenInfo(options) {
+  const readOnlyOptions = parseReadOnlyOptions({
+    chainId: options.chainId,
+    rpcUrl: options.rpcUrl
+  });
+  if (!isNetrSupportedChain(readOnlyOptions.chainId)) {
+    exitWithError(
+      `Chain ${readOnlyOptions.chainId} is not supported for Netr tokens`
+    );
+  }
+  const client = new NetrClient({
+    chainId: readOnlyOptions.chainId,
+    overrides: options.rpcUrl ? { rpcUrls: [options.rpcUrl] } : void 0
+  });
+  const tokenAddress = options.address;
+  try {
+    const [token, storageData, price] = await Promise.all([
+      client.getToken(tokenAddress),
+      client.getStorageData(tokenAddress),
+      client.getPrice(tokenAddress)
+    ]);
+    if (!token) {
+      exitWithError(`Token not found at address ${tokenAddress}`);
+      return;
+    }
+    let locker = null;
+    if (storageData?.lockerAddress) {
+      locker = await client.getLocker(storageData.lockerAddress);
+    }
+    if (options.json) {
+      const output = {
+        address: tokenAddress,
+        chainId: readOnlyOptions.chainId,
+        token: {
+          name: token.name,
+          symbol: token.symbol,
+          deployer: token.deployer,
+          image: token.image,
+          animation: token.animation || null,
+          fid: token.fid.toString(),
+          totalSupply: token.totalSupply.toString(),
+          decimals: token.decimals,
+          extraStringData: token.extraStringData || null
+        },
+        pool: storageData?.poolAddress || null,
+        locker: storageData?.lockerAddress || null,
+        price: price ? {
+          priceInEth: price.priceInEth,
+          priceInWeth: price.priceInWeth,
+          tick: price.tick
+        } : null,
+        lockerInfo: locker ? {
+          owner: locker.owner,
+          duration: locker.duration.toString(),
+          endTimestamp: locker.endTimestamp.toString(),
+          version: locker.version
+        } : null
+      };
+      console.log(JSON.stringify(output, null, 2));
+      return;
+    }
+    console.log(chalk4.white.bold("\nToken Info:\n"));
+    console.log(`  ${chalk4.cyan("Address:")} ${tokenAddress}`);
+    console.log(`  ${chalk4.cyan("Chain ID:")} ${readOnlyOptions.chainId}`);
+    console.log(`  ${chalk4.cyan("Name:")} ${token.name}`);
+    console.log(`  ${chalk4.cyan("Symbol:")} ${token.symbol}`);
+    console.log(`  ${chalk4.cyan("Deployer:")} ${token.deployer}`);
+    console.log(`  ${chalk4.cyan("FID:")} ${token.fid.toString()}`);
+    console.log(`  ${chalk4.cyan("Image:")} ${token.image}`);
+    if (token.animation) {
+      console.log(`  ${chalk4.cyan("Animation:")} ${token.animation}`);
+    }
+    if (token.extraStringData) {
+      console.log(`  ${chalk4.cyan("Extra Data:")} ${token.extraStringData}`);
+    }
+    if (storageData?.poolAddress) {
+      console.log(`  ${chalk4.cyan("Pool:")} ${storageData.poolAddress}`);
+    }
+    if (storageData?.lockerAddress) {
+      console.log(`  ${chalk4.cyan("Locker:")} ${storageData.lockerAddress}`);
+    }
+    if (price) {
+      console.log(`  ${chalk4.cyan("Price:")} ${price.priceInEth} ETH`);
+    }
+    if (locker) {
+      const endDate = new Date(Number(locker.endTimestamp) * 1e3);
+      console.log(
+        `  ${chalk4.cyan("Lock Ends:")} ${endDate.toLocaleDateString()}`
+      );
+    }
+    console.log();
+  } catch (error) {
+    exitWithError(
+      `Failed to get token info: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+
+// src/commands/token/index.ts
+function registerTokenCommand(program2) {
+  const tokenCommand = program2.command("token").description("Token operations (Netr/Banger)");
+  const deployCommand = new Command("deploy").description("Deploy a new Netr token").requiredOption("--name <name>", "Token name").requiredOption("--symbol <symbol>", "Token symbol").requiredOption("--image <url>", "Token image URL").option("--animation <url>", "Token animation URL").option("--fid <number>", "Farcaster ID").option(
+    "--private-key <key>",
+    "Private key (0x-prefixed hex). Can also be set via NET_PRIVATE_KEY env var"
+  ).option(
+    "--chain-id <id>",
+    "Chain ID. Can also be set via NET_CHAIN_ID env var",
+    (value) => parseInt(value, 10)
+  ).option(
+    "--rpc-url <url>",
+    "Custom RPC URL. Can also be set via NET_RPC_URL env var"
+  ).option(
+    "--encode-only",
+    "Output transaction data as JSON instead of executing"
+  ).option("--mint-price <wei>", "Mint price in wei for NFT drop").option("--mint-end-timestamp <timestamp>", "Unix timestamp when minting ends").option("--max-mint-supply <amount>", "Maximum mint supply for NFT drop").option("--metadata-address <address>", "Dynamic metadata contract address").option("--extra-string-data <data>", "Extra string data to store with token").option("--initial-buy <eth>", "ETH amount to swap for tokens on deploy (e.g., '0.001')").action(async (options) => {
+    await executeTokenDeploy({
+      name: options.name,
+      symbol: options.symbol,
+      image: options.image,
+      animation: options.animation,
+      fid: options.fid,
+      privateKey: options.privateKey,
+      chainId: options.chainId,
+      rpcUrl: options.rpcUrl,
+      encodeOnly: options.encodeOnly,
+      mintPrice: options.mintPrice,
+      mintEndTimestamp: options.mintEndTimestamp,
+      maxMintSupply: options.maxMintSupply,
+      metadataAddress: options.metadataAddress,
+      extraStringData: options.extraStringData,
+      initialBuy: options.initialBuy
+    });
+  });
+  const infoCommand = new Command("info").description("Get information about a Netr token").requiredOption("--address <address>", "Token address").option(
+    "--chain-id <id>",
+    "Chain ID. Can also be set via NET_CHAIN_ID env var",
+    (value) => parseInt(value, 10)
+  ).option(
+    "--rpc-url <url>",
+    "Custom RPC URL. Can also be set via NET_RPC_URL env var"
+  ).option("--json", "Output in JSON format").action(async (options) => {
+    await executeTokenInfo({
+      address: options.address,
+      chainId: options.chainId,
+      rpcUrl: options.rpcUrl,
+      json: options.json
+    });
+  });
+  tokenCommand.addCommand(deployCommand);
+  tokenCommand.addCommand(infoCommand);
 }
 
 // src/cli/index.ts
 var program = new Command();
 program.name("netp").description("CLI tool for Net Protocol").version("0.1.0");
 registerStorageCommand(program);
+registerMessageCommand(program);
+registerChainsCommand(program);
+registerInfoCommand(program);
+registerTokenCommand(program);
 program.parse();
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map