@net-protocol/cli 0.1.10 → 0.1.12

package/README.md

@@ -841,3 +841,108 @@ The CLI handles various error scenarios:
 - Storage read errors
 
 If a transaction fails mid-upload, you can safely retry the command - it will only upload missing chunks.
+
+#### Bazaar Command
+
+NFT Bazaar operations — list, buy, sell, and trade NFTs via Seaport.
+
+**Available Subcommands:**
+
+- `bazaar list-listings` - List active NFT listings
+- `bazaar list-offers` - List active collection offers
+- `bazaar list-sales` - List recent sales
+- `bazaar owned-nfts` - List NFTs owned by an address
+- `bazaar create-listing` - Create an NFT listing
+- `bazaar create-offer` - Create a collection offer
+- `bazaar submit-listing` - Submit a signed listing
+- `bazaar submit-offer` - Submit a signed offer
+- `bazaar buy-listing` - Buy an NFT listing
+- `bazaar accept-offer` - Accept a collection offer
+
+##### Read Commands
+
+```bash
+# List active listings (--nft-address optional for cross-collection)
+netp bazaar list-listings [--nft-address <address>] --chain-id 8453 [--json]
+
+# List collection offers
+netp bazaar list-offers --nft-address <address> --chain-id 8453 [--json]
+
+# List recent sales
+netp bazaar list-sales --nft-address <address> --chain-id 8453 [--json]
+
+# Check NFTs owned by an address
+netp bazaar owned-nfts --nft-address <address> --owner <address> --chain-id 8453 [--json]
+```
+
+##### Create Commands (Dual Mode)
+
+Create commands support two modes: with `--private-key` for full flow (approve + sign + submit), or without for EIP-712 output (external signing).
+
+```bash
+# Full flow with private key
+netp bazaar create-listing \
+  --nft-address <address> --token-id <id> --price <eth> \
+  --chain-id 8453 --private-key 0x...
+
+# Keyless: outputs EIP-712 data + approval txs for external signing
+netp bazaar create-listing \
+  --nft-address <address> --token-id <id> --price <eth> \
+  --offerer <address> --chain-id 8453
+
+# Same pattern for offers
+netp bazaar create-offer \
+  --nft-address <address> --price <eth> \
+  --chain-id 8453 --private-key 0x...
+```
+
+##### Submit Commands
+
+Follow-up to keyless create commands:
+
+```bash
+netp bazaar submit-listing \
+  --order-data <path> --signature <sig> \
+  --chain-id 8453 [--private-key 0x... | --encode-only]
+
+netp bazaar submit-offer \
+  --order-data <path> --signature <sig> \
+  --chain-id 8453 [--private-key 0x... | --encode-only]
+```
+
+##### Fulfillment Commands
+
+```bash
+# Buy a listing
+netp bazaar buy-listing \
+  --order-hash <hash> --nft-address <address> \
+  --chain-id 8453 [--private-key 0x... | --buyer <address> --encode-only]
+
+# Accept an offer (sell your NFT)
+netp bazaar accept-offer \
+  --order-hash <hash> --nft-address <address> --token-id <id> \
+  --chain-id 8453 [--private-key 0x... | --seller <address> --encode-only]
+```
+
+##### Encode-Only Mode
+
+All write commands support `--encode-only` for agent integration:
+
+```bash
+netp bazaar buy-listing \
+  --order-hash 0x... --nft-address 0x... \
+  --buyer 0xAgentWallet --chain-id 8453 --encode-only
+```
+
+Output:
+```json
+{
+  "approvals": [],
+  "fulfillment": {
+    "to": "0x...",
+    "data": "0x...",
+    "chainId": 8453,
+    "value": "10000000000000"
+  }
+}
+```

package/dist/cli/index.mjs

@@ -12,7 +12,7 @@ import { privateKeyToAccount } from 'viem/accounts';
 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, PROFILE_CANVAS_STORAGE_KEY, 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, getProfileMetadataStorageArgs, isValidBio, isValidTokenAddress } from '@net-protocol/profiles';
 import { base } from 'viem/chains';
 import * as path from 'path';
 import { BazaarClient } from '@net-protocol/bazaar';
@@ -1478,8 +1478,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: privateKeyToAccount16 } = await import('viem/accounts');
-      const userAccount = privateKeyToAccount16(commonOptions.privateKey);
+      const { privateKeyToAccount: privateKeyToAccount17 } = await import('viem/accounts');
+      const userAccount = privateKeyToAccount17(commonOptions.privateKey);
       const storageUrl = generateStorageUrl(
         userAccount.address,
         commonOptions.chainId,
@@ -2261,6 +2261,7 @@ async function executeProfileGet(options) {
     }
     let xUsername;
     let bio;
+    let tokenAddress;
     try {
       const metadataResult = await client.readStorageData({
         key: PROFILE_METADATA_STORAGE_KEY,
@@ -2270,6 +2271,7 @@ async function executeProfileGet(options) {
         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);
@@ -2294,7 +2296,7 @@ async function executeProfileGet(options) {
         throw error;
       }
     }
-    const hasProfile = profilePicture || xUsername || bio || canvasSize;
+    const hasProfile = profilePicture || xUsername || bio || tokenAddress || canvasSize;
     if (options.json) {
       const output = {
         address: options.address,
@@ -2302,6 +2304,7 @@ async function executeProfileGet(options) {
         profilePicture: profilePicture || null,
         xUsername: xUsername || null,
         bio: bio || null,
+        tokenAddress: tokenAddress || null,
         canvas: canvasSize ? { size: canvasSize, isDataUri: canvasIsDataUri } : null,
         hasProfile
       };
@@ -2320,6 +2323,9 @@ async function executeProfileGet(options) {
     console.log(
       `  ${chalk4.cyan("Bio:")} ${bio || chalk4.gray("(not set)")}`
     );
+    console.log(
+      `  ${chalk4.cyan("Token Address:")} ${tokenAddress || chalk4.gray("(not set)")}`
+    );
     console.log(
       `  ${chalk4.cyan("Canvas:")} ${canvasSize ? `${canvasSize} bytes${canvasIsDataUri ? " (data URI)" : ""}` : chalk4.gray("(not set)")}`
     );
@@ -2407,19 +2413,47 @@ async function executeProfileSetPicture(options) {
     );
   }
 }
+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 storageArgs = getXUsernameStorageArgs(options.username);
-  const displayUsername = options.username.startsWith("@") ? options.username : `@${options.username}`;
+  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,
@@ -2453,22 +2487,36 @@ async function executeProfileSetUsername(options) {
       // TODO: Support other chains
       transport: http(rpcUrls[0])
     }).extend(publicActions);
-    console.log(chalk4.blue(`\u{1F426} Setting X username...`));
+    console.log(chalk4.blue(`Setting X username...`));
     console.log(chalk4.gray(`   Username: ${displayUsername}`));
     console.log(chalk4.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(chalk4.blue(`\u23F3 Waiting for confirmation...`));
+    console.log(chalk4.blue(`Waiting for confirmation...`));
     const receipt = await client.waitForTransactionReceipt({ hash });
     if (receipt.status === "success") {
       console.log(
         chalk4.green(
           `
-\u2713 X username updated successfully!
+X username updated successfully!
   Transaction: ${hash}
   Username: ${displayUsername}`
         )
@@ -2488,12 +2536,12 @@ async function executeProfileSetBio(options) {
       `Invalid bio: "${options.bio}". Bio must be 1-280 characters and cannot contain control characters.`
     );
   }
-  const storageArgs = getProfileMetadataStorageArgs({ bio: options.bio });
   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,
@@ -2530,6 +2578,20 @@ async function executeProfileSetBio(options) {
     console.log(chalk4.blue(`Setting profile bio...`));
     console.log(chalk4.gray(`   Bio: ${options.bio}`));
     console.log(chalk4.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,
@@ -2556,6 +2618,97 @@ Bio updated successfully!
     );
   }
 }
+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(chalk4.blue(`Setting profile token address...`));
+    console.log(chalk4.gray(`   Token Address: ${normalizedAddress}`));
+    console.log(chalk4.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(chalk4.blue(`Waiting for confirmation...`));
+    const receipt = await client.waitForTransactionReceipt({ hash });
+    if (receipt.status === "success") {
+      console.log(
+        chalk4.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) {
@@ -2889,6 +3042,31 @@ function registerProfileCommand(program2) {
       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"
@@ -2932,6 +3110,7 @@ function registerProfileCommand(program2) {
   profileCommand.addCommand(setPictureCommand);
   profileCommand.addCommand(setUsernameCommand);
   profileCommand.addCommand(setBioCommand);
+  profileCommand.addCommand(setTokenAddressCommand);
   profileCommand.addCommand(setCanvasCommand);
   profileCommand.addCommand(getCanvasCommand);
 }
@@ -3862,7 +4041,7 @@ var privateKeyOption = [
   "Private key (0x-prefixed hex). Can also be set via NET_PRIVATE_KEY env var"
 ];
 function registerBazaarCommand(program2) {
-  const bazaarCommand = program2.command("bazaar").description("Bazaar NFT marketplace operations");
+  const bazaarCommand = program2.command("bazaar").description("Bazaar NFT trading operations");
   const listListingsCommand = new Command("list-listings").description("List active NFT listings").option("--nft-address <address>", "NFT contract address (optional for cross-collection)").option(...chainIdOption).option(...rpcUrlOption).option("--json", "Output in JSON format").action(async (options) => {
     await executeListListings({
       nftAddress: options.nftAddress,