npm - @net-protocol/cli - Versions diffs - 0.1.7 → 0.1.9 - Mend

@net-protocol/cli 0.1.7 → 0.1.9

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (4) hide show

package/README.md CHANGED Viewed

@@ -364,6 +364,8 @@ Profile operations for managing your Net Protocol profile.
 - `profile set-picture` - Set your profile picture URL
 - `profile set-x-username` - Set your X (Twitter) username
 - `profile set-bio` - Set your profile bio
+- `profile set-canvas` - Set your profile canvas (HTML content)
+- `profile get-canvas` - Get profile canvas for an address
 ##### Profile Get
@@ -513,6 +515,99 @@ netp profile set-bio \
   --encode-only
 ```
+##### Profile Set Canvas
+Set your profile canvas (HTML content, max 60KB). Canvas content is stored using ChunkedStorage with gzip compression.
+```bash
+netp profile set-canvas \
+  --file <path> | --content <html> \
+  [--private-key <0x...>] \
+  [--chain-id <8453|1|...>] \
+  [--rpc-url <custom-rpc>] \
+  [--encode-only]
+```
+**Profile Set Canvas Arguments:**
+- `--file` (optional): Path to file containing canvas content (HTML, images, etc.)
+- `--content` (optional): HTML content for canvas (inline). Must provide either `--file` or `--content`, but not both.
+- `--private-key` (optional): Private key. Can also be set via `NET_PRIVATE_KEY` environment variable
+- `--chain-id` (optional): Chain ID. Can also be set via `NET_CHAIN_ID` environment variable
+- `--rpc-url` (optional): Custom RPC URL. Can also be set via `NET_RPC_URL` environment variable
+- `--encode-only` (optional): Output transaction data as JSON instead of executing
+**Notes:**
+- Maximum canvas size is 60KB
+- Binary files (images) are automatically converted to data URIs
+- Content is compressed using gzip before storage
+**Example:**
+```bash
+# Set canvas from file
+netp profile set-canvas \
+  --file ./my-canvas.html \
+  --chain-id 8453
+# Set canvas from inline content
+netp profile set-canvas \
+  --content "<html><body><h1>My Profile</h1></body></html>" \
+  --chain-id 8453
+# Encode-only
+netp profile set-canvas \
+  --file ./my-canvas.html \
+  --chain-id 8453 \
+  --encode-only
+```
+##### Profile Get Canvas
+Get profile canvas for an address.
+```bash
+netp profile get-canvas \
+  --address <wallet-address> \
+  [--output <path>] \
+  [--chain-id <8453|1|...>] \
+  [--rpc-url <custom-rpc>] \
+  [--json]
+```
+**Profile Get Canvas Arguments:**
+- `--address` (required): Wallet address to get canvas for
+- `--output` (optional): Write canvas content to file instead of stdout
+- `--chain-id` (optional): Chain ID. Can also be set via `NET_CHAIN_ID` environment variable
+- `--rpc-url` (optional): Custom RPC URL. Can also be set via `NET_RPC_URL` environment variable
+- `--json` (optional): Output in JSON format (includes metadata like size and type)
+**Notes:**
+- Binary content (data URIs) is automatically converted to binary files when using `--output`
+- JSON output includes: canvas content, filename, size, and whether it's a data URI
+**Example:**
+```bash
+# Output to stdout
+netp profile get-canvas \
+  --address 0x1234567890abcdef1234567890abcdef12345678 \
+  --chain-id 8453
+# Save to file
+netp profile get-canvas \
+  --address 0x1234567890abcdef1234567890abcdef12345678 \
+  --output ./canvas.html \
+  --chain-id 8453
+# JSON output
+netp profile get-canvas \
+  --address 0x1234567890abcdef1234567890abcdef12345678 \
+  --chain-id 8453 \
+  --json
+```
 #### Info Command
 Show contract info and stats.

package/dist/cli/index.mjs CHANGED Viewed

@@ -1,18 +1,20 @@
 #!/usr/bin/env node
+import { ProxyAgent, setGlobalDispatcher } from 'undici';
 import 'dotenv/config';
 import { Command } from 'commander';
 import { createRequire } from 'module';
 import chalk4 from 'chalk';
-import * as fs from 'fs';
+import * as fs2 from 'fs';
 import { readFileSync } from 'fs';
-import { StorageClient, detectFileTypeFromBase64, base64ToDataUri, shouldSuggestXmlStorage, getStorageKeyBytes, encodeStorageKeyForUrl, STORAGE_CONTRACT as STORAGE_CONTRACT$1, CHUNKED_STORAGE_CONTRACT } from '@net-protocol/storage';
+import { StorageClient, detectFileTypeFromBase64, base64ToDataUri, shouldSuggestXmlStorage, getStorageKeyBytes, encodeStorageKeyForUrl, chunkDataForStorage, CHUNKED_STORAGE_CONTRACT, STORAGE_CONTRACT as STORAGE_CONTRACT$1 } from '@net-protocol/storage';
 import { stringToHex, createWalletClient, http, hexToString, parseEther, encodeFunctionData, publicActions, defineChain } from 'viem';
 import { privateKeyToAccount } from 'viem/accounts';
-import { getNetContract, getChainName, getPublicClient, getChainRpcUrls, NetClient } from '@net-protocol/core';
+import { getNetContract, getChainName, getPublicClient, getChainRpcUrls, NetClient, toBytes32 } 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';
-import { PROFILE_PICTURE_STORAGE_KEY, PROFILE_METADATA_STORAGE_KEY, parseProfileMetadata, isValidUrl, getProfilePictureStorageArgs, STORAGE_CONTRACT, isValidXUsername, getXUsernameStorageArgs, isValidBio, getProfileMetadataStorageArgs } from '@net-protocol/profiles';
+import { PROFILE_PICTURE_STORAGE_KEY, PROFILE_METADATA_STORAGE_KEY, parseProfileMetadata, PROFILE_CANVAS_STORAGE_KEY, isValidUrl, getProfilePictureStorageArgs, STORAGE_CONTRACT, isValidXUsername, getXUsernameStorageArgs, isValidBio, getProfileMetadataStorageArgs } from '@net-protocol/profiles';
 import { base } from 'viem/chains';
+import * as path from 'path';
 function getRequiredChainId(optionValue) {
   const chainId = optionValue || (process.env.NET_CHAIN_ID ? parseInt(process.env.NET_CHAIN_ID, 10) : void 0);
@@ -1191,7 +1193,7 @@ async function encodeStorageUpload(options) {
   } else {
     operatorAddress = "0x0000000000000000000000000000000000000000";
   }
-  const fileContent = fs.readFileSync(options.filePath, "utf-8");
+  const fileContent = fs2.readFileSync(options.filePath, "utf-8");
   const fileSize = Buffer.byteLength(fileContent, "utf-8");
   const client = new StorageClient({
     chainId: readOnlyOptions.chainId
@@ -1475,8 +1477,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: privateKeyToAccount9 } = await import('viem/accounts');
-      const userAccount = privateKeyToAccount9(commonOptions.privateKey);
+      const { privateKeyToAccount: privateKeyToAccount10 } = await import('viem/accounts');
+      const userAccount = privateKeyToAccount10(commonOptions.privateKey);
       const storageUrl = generateStorageUrl(
         userAccount.address,
         commonOptions.chainId,
@@ -2274,7 +2276,24 @@ async function executeProfileGet(options) {
         throw error;
       }
     }
-    const hasProfile = profilePicture || xUsername || bio;
+    let canvasSize;
+    let canvasIsDataUri = false;
+    try {
+      const canvasResult = await client.readChunkedStorage({
+        key: PROFILE_CANVAS_STORAGE_KEY,
+        operator: options.address
+      });
+      if (canvasResult.data) {
+        canvasSize = canvasResult.data.length;
+        canvasIsDataUri = canvasResult.data.startsWith("data:");
+      }
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      if (errorMessage !== "ChunkedStorage metadata not found" && !errorMessage.includes("not found")) {
+        throw error;
+      }
+    }
+    const hasProfile = profilePicture || xUsername || bio || canvasSize;
     if (options.json) {
       const output = {
         address: options.address,
@@ -2282,6 +2301,7 @@ async function executeProfileGet(options) {
         profilePicture: profilePicture || null,
         xUsername: xUsername || null,
         bio: bio || null,
+        canvas: canvasSize ? { size: canvasSize, isDataUri: canvasIsDataUri } : null,
         hasProfile
       };
       console.log(JSON.stringify(output, null, 2));
@@ -2299,6 +2319,9 @@ async function executeProfileGet(options) {
     console.log(
       `  ${chalk4.cyan("Bio:")} ${bio || chalk4.gray("(not set)")}`
     );
+    console.log(
+      `  ${chalk4.cyan("Canvas:")} ${canvasSize ? `${canvasSize} bytes${canvasIsDataUri ? " (data URI)" : ""}` : chalk4.gray("(not set)")}`
+    );
     if (!hasProfile) {
       console.log(chalk4.yellow("\n  No profile data found for this address."));
     }
@@ -2532,6 +2555,251 @@ Bio updated successfully!
     );
   }
 }
+var MAX_CANVAS_SIZE = 60 * 1024;
+var CANVAS_FILENAME = "profile-compressed.html";
+function isBinaryContent(buffer) {
+  const sampleSize = Math.min(buffer.length, 8192);
+  for (let i = 0; i < sampleSize; i++) {
+    const byte = buffer[i];
+    if (byte === 0) return true;
+    if (byte < 32 && byte !== 9 && byte !== 10 && byte !== 13) return true;
+  }
+  return false;
+}
+function getMimeType(filePath) {
+  const ext = path.extname(filePath).toLowerCase();
+  const mimeTypes = {
+    ".png": "image/png",
+    ".jpg": "image/jpeg",
+    ".jpeg": "image/jpeg",
+    ".gif": "image/gif",
+    ".webp": "image/webp",
+    ".svg": "image/svg+xml",
+    ".pdf": "application/pdf",
+    ".html": "text/html",
+    ".htm": "text/html",
+    ".css": "text/css",
+    ".js": "application/javascript",
+    ".json": "application/json",
+    ".txt": "text/plain"
+  };
+  return mimeTypes[ext] || "application/octet-stream";
+}
+function bufferToDataUri(buffer, mimeType) {
+  const base64 = buffer.toString("base64");
+  return `data:${mimeType};base64,${base64}`;
+}
+async function executeProfileSetCanvas(options) {
+  if (!options.file && !options.content) {
+    exitWithError(
+      "Must provide either --file or --content to set canvas content."
+    );
+  }
+  if (options.file && options.content) {
+    exitWithError("Cannot provide both --file and --content. Choose one.");
+  }
+  let canvasContent;
+  if (options.file) {
+    const filePath = path.resolve(options.file);
+    if (!fs2.existsSync(filePath)) {
+      exitWithError(`File not found: ${filePath}`);
+    }
+    const buffer = fs2.readFileSync(filePath);
+    if (buffer.length > MAX_CANVAS_SIZE) {
+      exitWithError(
+        `File too large: ${buffer.length} bytes exceeds maximum of ${MAX_CANVAS_SIZE} bytes (60KB).`
+      );
+    }
+    if (isBinaryContent(buffer)) {
+      const mimeType = getMimeType(filePath);
+      canvasContent = bufferToDataUri(buffer, mimeType);
+    } else {
+      canvasContent = buffer.toString("utf-8");
+    }
+  } else {
+    canvasContent = options.content;
+    const contentSize = Buffer.byteLength(canvasContent, "utf-8");
+    if (contentSize > MAX_CANVAS_SIZE) {
+      exitWithError(
+        `Content too large: ${contentSize} bytes exceeds maximum of ${MAX_CANVAS_SIZE} bytes (60KB).`
+      );
+    }
+  }
+  const bytesKey = toBytes32(PROFILE_CANVAS_STORAGE_KEY);
+  const chunks = chunkDataForStorage(canvasContent);
+  if (options.encodeOnly) {
+    const readOnlyOptions = parseReadOnlyOptions({
+      chainId: options.chainId,
+      rpcUrl: options.rpcUrl
+    });
+    const encoded = encodeTransaction(
+      {
+        to: CHUNKED_STORAGE_CONTRACT.address,
+        abi: CHUNKED_STORAGE_CONTRACT.abi,
+        functionName: "put",
+        args: [bytesKey, CANVAS_FILENAME, chunks]
+      },
+      readOnlyOptions.chainId
+    );
+    console.log(JSON.stringify(encoded, null, 2));
+    return;
+  }
+  const commonOptions = parseCommonOptions(
+    {
+      privateKey: options.privateKey,
+      chainId: options.chainId,
+      rpcUrl: options.rpcUrl
+    },
+    true
+    // supports --encode-only
+  );
+  try {
+    const account = privateKeyToAccount(commonOptions.privateKey);
+    const rpcUrls = getChainRpcUrls({
+      chainId: commonOptions.chainId,
+      rpcUrl: commonOptions.rpcUrl
+    });
+    const client = createWalletClient({
+      account,
+      chain: base,
+      // TODO: Support other chains
+      transport: http(rpcUrls[0])
+    }).extend(publicActions);
+    console.log(chalk4.blue(`Setting profile canvas...`));
+    console.log(
+      chalk4.gray(`   Content size: ${Buffer.byteLength(canvasContent)} bytes`)
+    );
+    console.log(chalk4.gray(`   Chunks: ${chunks.length}`));
+    console.log(chalk4.gray(`   Address: ${account.address}`));
+    const hash = await client.writeContract({
+      address: CHUNKED_STORAGE_CONTRACT.address,
+      abi: CHUNKED_STORAGE_CONTRACT.abi,
+      functionName: "put",
+      args: [bytesKey, CANVAS_FILENAME, chunks]
+    });
+    console.log(chalk4.blue(`Waiting for confirmation...`));
+    const receipt = await client.waitForTransactionReceipt({ hash });
+    if (receipt.status === "success") {
+      console.log(
+        chalk4.green(
+          `
+Canvas updated successfully!
+  Transaction: ${hash}
+  Content size: ${Buffer.byteLength(canvasContent)} bytes
+  Chunks: ${chunks.length}`
+        )
+      );
+    } else {
+      exitWithError(`Transaction failed: ${hash}`);
+    }
+  } catch (error) {
+    exitWithError(
+      `Failed to set canvas: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+function isDataUri(content) {
+  return content.startsWith("data:");
+}
+function parseDataUri(dataUri) {
+  const match = dataUri.match(/^data:([^;]+);base64,(.+)$/);
+  if (!match) {
+    throw new Error("Invalid data URI format");
+  }
+  const mimeType = match[1];
+  const base64Data = match[2];
+  const buffer = Buffer.from(base64Data, "base64");
+  return { buffer, mimeType };
+}
+function getExtensionFromMimeType(mimeType) {
+  const extensions = {
+    "image/png": ".png",
+    "image/jpeg": ".jpg",
+    "image/gif": ".gif",
+    "image/webp": ".webp",
+    "image/svg+xml": ".svg",
+    "application/pdf": ".pdf",
+    "text/html": ".html",
+    "text/css": ".css",
+    "application/javascript": ".js",
+    "application/json": ".json",
+    "text/plain": ".txt",
+    "application/octet-stream": ".bin"
+  };
+  return extensions[mimeType] || ".bin";
+}
+async function executeProfileGetCanvas(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 {
+    let canvasContent;
+    let canvasText;
+    try {
+      const result = await client.readChunkedStorage({
+        key: PROFILE_CANVAS_STORAGE_KEY,
+        operator: options.address
+      });
+      if (result.data) {
+        canvasContent = result.data;
+        canvasText = result.text;
+      }
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      if (errorMessage !== "ChunkedStorage metadata not found" && !errorMessage.includes("not found")) {
+        throw error;
+      }
+    }
+    if (options.json) {
+      const output = {
+        address: options.address,
+        chainId: readOnlyOptions.chainId,
+        canvas: canvasContent || null,
+        filename: canvasText || null,
+        hasCanvas: !!canvasContent,
+        isDataUri: canvasContent ? isDataUri(canvasContent) : false,
+        contentLength: canvasContent ? canvasContent.length : 0
+      };
+      console.log(JSON.stringify(output, null, 2));
+      return;
+    }
+    if (!canvasContent) {
+      exitWithError(`No canvas found for address: ${options.address}`);
+    }
+    if (options.output) {
+      const outputPath = path.resolve(options.output);
+      if (isDataUri(canvasContent)) {
+        const { buffer, mimeType } = parseDataUri(canvasContent);
+        let finalPath = outputPath;
+        if (!path.extname(outputPath)) {
+          finalPath = outputPath + getExtensionFromMimeType(mimeType);
+        }
+        fs2.writeFileSync(finalPath, buffer);
+        console.log(
+          chalk4.green(`Canvas written to: ${finalPath} (${buffer.length} bytes)`)
+        );
+      } else {
+        fs2.writeFileSync(outputPath, canvasContent, "utf-8");
+        console.log(
+          chalk4.green(
+            `Canvas written to: ${outputPath} (${canvasContent.length} bytes)`
+          )
+        );
+      }
+      return;
+    }
+    console.log(canvasContent);
+  } catch (error) {
+    exitWithError(
+      `Failed to read canvas: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
 // src/commands/profile/index.ts
 function registerProfileCommand(program2) {
@@ -2620,13 +2888,59 @@ function registerProfileCommand(program2) {
       encodeOnly: options.encodeOnly
     });
   });
+  const setCanvasCommand = new Command("set-canvas").description("Set your profile canvas (HTML content)").option("--file <path>", "Path to file containing canvas content").option("--content <html>", "HTML content for canvas (inline)").option(
+    "--private-key <key>",
+    "Private key (0x-prefixed hex, 66 characters). 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 executeProfileSetCanvas({
+      file: options.file,
+      content: options.content,
+      privateKey: options.privateKey,
+      chainId: options.chainId,
+      rpcUrl: options.rpcUrl,
+      encodeOnly: options.encodeOnly
+    });
+  });
+  const getCanvasCommand = new Command("get-canvas").description("Get profile canvas for an address").requiredOption("--address <address>", "Wallet address to get canvas for").option("--output <path>", "Write canvas content to file instead of stdout").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 executeProfileGetCanvas({
+      address: options.address,
+      output: options.output,
+      chainId: options.chainId,
+      rpcUrl: options.rpcUrl,
+      json: options.json
+    });
+  });
   profileCommand.addCommand(getCommand);
   profileCommand.addCommand(setPictureCommand);
   profileCommand.addCommand(setUsernameCommand);
   profileCommand.addCommand(setBioCommand);
+  profileCommand.addCommand(setCanvasCommand);
+  profileCommand.addCommand(getCanvasCommand);
 }
 // src/cli/index.ts
+var proxyUrl = process.env.https_proxy || process.env.HTTPS_PROXY;
+if (proxyUrl) {
+  const agent = new ProxyAgent(proxyUrl);
+  setGlobalDispatcher(agent);
+}
 var require2 = createRequire(import.meta.url);
 var { version } = require2("../../package.json");
 var program = new Command();