@net-protocol/cli 0.1.13 → 0.1.15

package/dist/profile/index.mjs

@@ -0,0 +1,970 @@
+import { Command } from 'commander';
+import chalk3 from 'chalk';
+import { StorageClient, chunkDataForStorage, CHUNKED_STORAGE_CONTRACT } from '@net-protocol/storage';
+import { PROFILE_PICTURE_STORAGE_KEY, PROFILE_METADATA_STORAGE_KEY, parseProfileMetadata, PROFILE_CANVAS_STORAGE_KEY, isValidUrl, getProfilePictureStorageArgs, STORAGE_CONTRACT, isValidXUsername, getProfileMetadataStorageArgs, isValidBio, isValidTokenAddress } from '@net-protocol/profiles';
+import { createWalletClient, http, publicActions, encodeFunctionData } from 'viem';
+import { privateKeyToAccount } from 'viem/accounts';
+import { base } from 'viem/chains';
+import { getChainRpcUrls, toBytes32 } from '@net-protocol/core';
+import * as fs from 'fs';
+import * as path from 'path';
+
+// src/commands/profile/index.ts
+function getRequiredChainId(optionValue) {
+  const chainId = optionValue || (process.env.NET_CHAIN_ID ? parseInt(process.env.NET_CHAIN_ID, 10) : void 0);
+  if (!chainId) {
+    console.error(
+      chalk3.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, supportsEncodeOnly = false) {
+  const privateKey = options.privateKey || process.env.NET_PRIVATE_KEY || process.env.PRIVATE_KEY;
+  if (!privateKey) {
+    const encodeOnlyHint = supportsEncodeOnly ? ", or use --encode-only to output transaction data without submitting" : "";
+    console.error(
+      chalk3.red(
+        `Error: Private key is required. Provide via --private-key flag or NET_PRIVATE_KEY/PRIVATE_KEY environment variable${encodeOnlyHint}`
+      )
+    );
+    process.exit(1);
+  }
+  if (!privateKey.startsWith("0x") || privateKey.length !== 66) {
+    console.error(
+      chalk3.red(
+        "Error: Invalid private key format (must be 0x-prefixed, 66 characters)"
+      )
+    );
+    process.exit(1);
+  }
+  if (options.privateKey) {
+    console.warn(
+      chalk3.yellow(
+        "Warning: Private key provided via command line. Consider using NET_PRIVATE_KEY environment variable instead."
+      )
+    );
+  }
+  return {
+    privateKey,
+    chainId: getRequiredChainId(options.chainId),
+    rpcUrl: getRpcUrl(options.rpcUrl)
+  };
+}
+function parseReadOnlyOptions(options) {
+  return {
+    chainId: getRequiredChainId(options.chainId),
+    rpcUrl: getRpcUrl(options.rpcUrl)
+  };
+}
+function exitWithError(message) {
+  console.error(chalk3.red(`Error: ${message}`));
+  process.exit(1);
+}
+
+// src/commands/profile/get.ts
+async function executeProfileGet(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 profilePicture;
+    try {
+      const pictureResult = await client.readStorageData({
+        key: PROFILE_PICTURE_STORAGE_KEY,
+        operator: options.address
+      });
+      if (pictureResult.data) {
+        profilePicture = pictureResult.data;
+      }
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      if (errorMessage !== "StoredDataNotFound") {
+        throw error;
+      }
+    }
+    let xUsername;
+    let bio;
+    let tokenAddress;
+    try {
+      const metadataResult = await client.readStorageData({
+        key: PROFILE_METADATA_STORAGE_KEY,
+        operator: options.address
+      });
+      if (metadataResult.data) {
+        const metadata = parseProfileMetadata(metadataResult.data);
+        xUsername = metadata?.x_username;
+        bio = metadata?.bio;
+        tokenAddress = metadata?.token_address;
+      }
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      if (errorMessage !== "StoredDataNotFound") {
+        throw error;
+      }
+    }
+    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 || tokenAddress || canvasSize;
+    if (options.json) {
+      const output = {
+        address: options.address,
+        chainId: readOnlyOptions.chainId,
+        profilePicture: profilePicture || null,
+        xUsername: xUsername || null,
+        bio: bio || null,
+        tokenAddress: tokenAddress || null,
+        canvas: canvasSize ? { size: canvasSize, isDataUri: canvasIsDataUri } : null,
+        hasProfile
+      };
+      console.log(JSON.stringify(output, null, 2));
+      return;
+    }
+    console.log(chalk3.white.bold("\nProfile:\n"));
+    console.log(`  ${chalk3.cyan("Address:")} ${options.address}`);
+    console.log(`  ${chalk3.cyan("Chain ID:")} ${readOnlyOptions.chainId}`);
+    console.log(
+      `  ${chalk3.cyan("Profile Picture:")} ${profilePicture || chalk3.gray("(not set)")}`
+    );
+    console.log(
+      `  ${chalk3.cyan("X Username:")} ${xUsername ? `@${xUsername}` : chalk3.gray("(not set)")}`
+    );
+    console.log(
+      `  ${chalk3.cyan("Bio:")} ${bio || chalk3.gray("(not set)")}`
+    );
+    console.log(
+      `  ${chalk3.cyan("Token Address:")} ${tokenAddress || chalk3.gray("(not set)")}`
+    );
+    console.log(
+      `  ${chalk3.cyan("Canvas:")} ${canvasSize ? `${canvasSize} bytes${canvasIsDataUri ? " (data URI)" : ""}` : chalk3.gray("(not set)")}`
+    );
+    if (!hasProfile) {
+      console.log(chalk3.yellow("\n  No profile data found for this address."));
+    }
+    console.log();
+  } catch (error) {
+    exitWithError(
+      `Failed to read profile: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+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/profile/set-picture.ts
+async function executeProfileSetPicture(options) {
+  if (!isValidUrl(options.url)) {
+    exitWithError(
+      `Invalid URL: "${options.url}". Please provide a valid URL (e.g., https://example.com/image.jpg)`
+    );
+  }
+  const storageArgs = getProfilePictureStorageArgs(options.url);
+  if (options.encodeOnly) {
+    const readOnlyOptions = parseReadOnlyOptions({
+      chainId: options.chainId,
+      rpcUrl: options.rpcUrl
+    });
+    const encoded = encodeTransaction(
+      {
+        to: STORAGE_CONTRACT.address,
+        abi: STORAGE_CONTRACT.abi,
+        functionName: "put",
+        args: [storageArgs.bytesKey, storageArgs.topic, storageArgs.bytesValue]
+      },
+      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(chalk3.blue(`\u{1F4F7} Setting profile picture...`));
+    console.log(chalk3.gray(`   URL: ${options.url}`));
+    console.log(chalk3.gray(`   Address: ${account.address}`));
+    const hash = await client.writeContract({
+      address: STORAGE_CONTRACT.address,
+      abi: STORAGE_CONTRACT.abi,
+      functionName: "put",
+      args: [storageArgs.bytesKey, storageArgs.topic, storageArgs.bytesValue]
+    });
+    console.log(chalk3.blue(`\u23F3 Waiting for confirmation...`));
+    const receipt = await client.waitForTransactionReceipt({ hash });
+    if (receipt.status === "success") {
+      console.log(
+        chalk3.green(
+          `
+\u2713 Profile picture updated successfully!
+  Transaction: ${hash}
+  URL: ${options.url}`
+        )
+      );
+    } else {
+      exitWithError(`Transaction failed: ${hash}`);
+    }
+  } catch (error) {
+    exitWithError(
+      `Failed to set profile picture: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+async function readExistingMetadata(address, client) {
+  try {
+    const metadataResult = await client.readStorageData({
+      key: PROFILE_METADATA_STORAGE_KEY,
+      operator: address
+    });
+    if (metadataResult.data) {
+      const metadata = parseProfileMetadata(metadataResult.data);
+      return {
+        x_username: metadata?.x_username,
+        bio: metadata?.bio,
+        display_name: metadata?.display_name,
+        token_address: metadata?.token_address
+      };
+    }
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    if (errorMessage !== "StoredDataNotFound") {
+      throw error;
+    }
+  }
+  return {};
+}
+
+// src/commands/profile/set-username.ts
+async function executeProfileSetUsername(options) {
+  if (!isValidXUsername(options.username)) {
+    exitWithError(
+      `Invalid X username: "${options.username}". Usernames must be 1-15 characters, alphanumeric and underscores only.`
+    );
+  }
+  const usernameForStorage = options.username.startsWith("@") ? options.username.slice(1) : options.username;
+  const displayUsername = `@${usernameForStorage}`;
+  if (options.encodeOnly) {
+    const readOnlyOptions = parseReadOnlyOptions({
+      chainId: options.chainId,
+      rpcUrl: options.rpcUrl
+    });
+    const storageArgs = getProfileMetadataStorageArgs({
+      x_username: usernameForStorage
+    });
+    const encoded = encodeTransaction(
+      {
+        to: STORAGE_CONTRACT.address,
+        abi: STORAGE_CONTRACT.abi,
+        functionName: "put",
+        args: [storageArgs.bytesKey, storageArgs.topic, storageArgs.bytesValue]
+      },
+      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(chalk3.blue(`Setting X username...`));
+    console.log(chalk3.gray(`   Username: ${displayUsername}`));
+    console.log(chalk3.gray(`   Address: ${account.address}`));
+    const storageClient = new StorageClient({
+      chainId: commonOptions.chainId,
+      overrides: commonOptions.rpcUrl ? { rpcUrls: [commonOptions.rpcUrl] } : void 0
+    });
+    const existing = await readExistingMetadata(
+      account.address,
+      storageClient
+    );
+    const storageArgs = getProfileMetadataStorageArgs({
+      x_username: usernameForStorage,
+      bio: existing.bio,
+      display_name: existing.display_name,
+      token_address: existing.token_address
+    });
+    const hash = await client.writeContract({
+      address: STORAGE_CONTRACT.address,
+      abi: STORAGE_CONTRACT.abi,
+      functionName: "put",
+      args: [storageArgs.bytesKey, storageArgs.topic, storageArgs.bytesValue]
+    });
+    console.log(chalk3.blue(`Waiting for confirmation...`));
+    const receipt = await client.waitForTransactionReceipt({ hash });
+    if (receipt.status === "success") {
+      console.log(
+        chalk3.green(
+          `
+X username updated successfully!
+  Transaction: ${hash}
+  Username: ${displayUsername}`
+        )
+      );
+    } else {
+      exitWithError(`Transaction failed: ${hash}`);
+    }
+  } catch (error) {
+    exitWithError(
+      `Failed to set X username: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+async function executeProfileSetBio(options) {
+  if (!isValidBio(options.bio)) {
+    exitWithError(
+      `Invalid bio: "${options.bio}". Bio must be 1-280 characters and cannot contain control characters.`
+    );
+  }
+  if (options.encodeOnly) {
+    const readOnlyOptions = parseReadOnlyOptions({
+      chainId: options.chainId,
+      rpcUrl: options.rpcUrl
+    });
+    const storageArgs = getProfileMetadataStorageArgs({ bio: options.bio });
+    const encoded = encodeTransaction(
+      {
+        to: STORAGE_CONTRACT.address,
+        abi: STORAGE_CONTRACT.abi,
+        functionName: "put",
+        args: [storageArgs.bytesKey, storageArgs.topic, storageArgs.bytesValue]
+      },
+      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(chalk3.blue(`Setting profile bio...`));
+    console.log(chalk3.gray(`   Bio: ${options.bio}`));
+    console.log(chalk3.gray(`   Address: ${account.address}`));
+    const storageClient = new StorageClient({
+      chainId: commonOptions.chainId,
+      overrides: commonOptions.rpcUrl ? { rpcUrls: [commonOptions.rpcUrl] } : void 0
+    });
+    const existing = await readExistingMetadata(
+      account.address,
+      storageClient
+    );
+    const storageArgs = getProfileMetadataStorageArgs({
+      bio: options.bio,
+      x_username: existing.x_username,
+      display_name: existing.display_name,
+      token_address: existing.token_address
+    });
+    const hash = await client.writeContract({
+      address: STORAGE_CONTRACT.address,
+      abi: STORAGE_CONTRACT.abi,
+      functionName: "put",
+      args: [storageArgs.bytesKey, storageArgs.topic, storageArgs.bytesValue]
+    });
+    console.log(chalk3.blue(`Waiting for confirmation...`));
+    const receipt = await client.waitForTransactionReceipt({ hash });
+    if (receipt.status === "success") {
+      console.log(
+        chalk3.green(
+          `
+Bio updated successfully!
+  Transaction: ${hash}
+  Bio: ${options.bio}`
+        )
+      );
+    } else {
+      exitWithError(`Transaction failed: ${hash}`);
+    }
+  } catch (error) {
+    exitWithError(
+      `Failed to set bio: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+async function executeProfileSetTokenAddress(options) {
+  if (!isValidTokenAddress(options.tokenAddress)) {
+    exitWithError(
+      `Invalid token address: "${options.tokenAddress}". Must be a valid EVM address (0x-prefixed, 40 hex characters).`
+    );
+  }
+  const normalizedAddress = options.tokenAddress.toLowerCase();
+  if (options.encodeOnly) {
+    const readOnlyOptions = parseReadOnlyOptions({
+      chainId: options.chainId,
+      rpcUrl: options.rpcUrl
+    });
+    const storageArgs = getProfileMetadataStorageArgs({
+      token_address: normalizedAddress
+    });
+    const encoded = encodeTransaction(
+      {
+        to: STORAGE_CONTRACT.address,
+        abi: STORAGE_CONTRACT.abi,
+        functionName: "put",
+        args: [storageArgs.bytesKey, storageArgs.topic, storageArgs.bytesValue]
+      },
+      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(chalk3.blue(`Setting profile token address...`));
+    console.log(chalk3.gray(`   Token Address: ${normalizedAddress}`));
+    console.log(chalk3.gray(`   Address: ${account.address}`));
+    const storageClient = new StorageClient({
+      chainId: commonOptions.chainId,
+      overrides: commonOptions.rpcUrl ? { rpcUrls: [commonOptions.rpcUrl] } : void 0
+    });
+    const existing = await readExistingMetadata(
+      account.address,
+      storageClient
+    );
+    const storageArgs = getProfileMetadataStorageArgs({
+      token_address: normalizedAddress,
+      x_username: existing.x_username,
+      bio: existing.bio,
+      display_name: existing.display_name
+    });
+    const hash = await client.writeContract({
+      address: STORAGE_CONTRACT.address,
+      abi: STORAGE_CONTRACT.abi,
+      functionName: "put",
+      args: [storageArgs.bytesKey, storageArgs.topic, storageArgs.bytesValue]
+    });
+    console.log(chalk3.blue(`Waiting for confirmation...`));
+    const receipt = await client.waitForTransactionReceipt({ hash });
+    if (receipt.status === "success") {
+      console.log(
+        chalk3.green(
+          `
+Token address updated successfully!
+  Transaction: ${hash}
+  Token Address: ${normalizedAddress}`
+        )
+      );
+    } else {
+      exitWithError(`Transaction failed: ${hash}`);
+    }
+  } catch (error) {
+    exitWithError(
+      `Failed to set token address: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+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 (!fs.existsSync(filePath)) {
+      exitWithError(`File not found: ${filePath}`);
+    }
+    const buffer = fs.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(chalk3.blue(`Setting profile canvas...`));
+    console.log(
+      chalk3.gray(`   Content size: ${Buffer.byteLength(canvasContent)} bytes`)
+    );
+    console.log(chalk3.gray(`   Chunks: ${chunks.length}`));
+    console.log(chalk3.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(chalk3.blue(`Waiting for confirmation...`));
+    const receipt = await client.waitForTransactionReceipt({ hash });
+    if (receipt.status === "success") {
+      console.log(
+        chalk3.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);
+        }
+        fs.writeFileSync(finalPath, buffer);
+        console.log(
+          chalk3.green(`Canvas written to: ${finalPath} (${buffer.length} bytes)`)
+        );
+      } else {
+        fs.writeFileSync(outputPath, canvasContent, "utf-8");
+        console.log(
+          chalk3.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(program) {
+  const profileCommand = program.command("profile").description("User profile operations");
+  const getCommand = new Command("get").description("Get profile data for an address").requiredOption("--address <address>", "Wallet address to get profile for").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 executeProfileGet({
+      address: options.address,
+      chainId: options.chainId,
+      rpcUrl: options.rpcUrl,
+      json: options.json
+    });
+  });
+  const setPictureCommand = new Command("set-picture").description("Set your profile picture URL").requiredOption("--url <url>", "Image URL for profile picture").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 executeProfileSetPicture({
+      url: options.url,
+      privateKey: options.privateKey,
+      chainId: options.chainId,
+      rpcUrl: options.rpcUrl,
+      encodeOnly: options.encodeOnly
+    });
+  });
+  const setUsernameCommand = new Command("set-x-username").description("Set your X (Twitter) username for your profile").requiredOption(
+    "--username <username>",
+    "Your X (Twitter) username (with or without @)"
+  ).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 executeProfileSetUsername({
+      username: options.username,
+      privateKey: options.privateKey,
+      chainId: options.chainId,
+      rpcUrl: options.rpcUrl,
+      encodeOnly: options.encodeOnly
+    });
+  });
+  const setBioCommand = new Command("set-bio").description("Set your profile bio").requiredOption("--bio <bio>", "Your profile bio (max 280 characters)").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 executeProfileSetBio({
+      bio: options.bio,
+      privateKey: options.privateKey,
+      chainId: options.chainId,
+      rpcUrl: options.rpcUrl,
+      encodeOnly: options.encodeOnly
+    });
+  });
+  const setTokenAddressCommand = new Command("set-token-address").description("Set your profile token address (ERC-20 token that represents you)").requiredOption(
+    "--token-address <address>",
+    "ERC-20 token contract address (0x-prefixed)"
+  ).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 executeProfileSetTokenAddress({
+      tokenAddress: options.tokenAddress,
+      privateKey: options.privateKey,
+      chainId: options.chainId,
+      rpcUrl: options.rpcUrl,
+      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(setTokenAddressCommand);
+  profileCommand.addCommand(setCanvasCommand);
+  profileCommand.addCommand(getCanvasCommand);
+}
+
+export { registerProfileCommand };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map