@net-protocol/cli 0.1.0

package/dist/cli/index.mjs

@@ -0,0 +1,1291 @@
+#!/usr/bin/env node
+import 'dotenv/config';
+import { Command } from 'commander';
+import chalk2 from 'chalk';
+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 { privateKeyToAccount } from 'viem/accounts';
+import { getPublicClient, getChainRpcUrls } from '@net-protocol/core';
+import { createRelayX402Client, createRelaySession, checkBackendWalletBalance, fundBackendWallet, batchTransactions, submitTransactionsViaRelay, waitForConfirmations, retryFailedTransactions as retryFailedTransactions$1 } from '@net-protocol/relay';
+
+function parseCommonOptions(options) {
+  const privateKey = options.privateKey || process.env.NET_PRIVATE_KEY || process.env.PRIVATE_KEY;
+  if (!privateKey) {
+    console.error(
+      chalk2.red(
+        "Error: Private key is required. Provide via --private-key flag or NET_PRIVATE_KEY/PRIVATE_KEY environment variable"
+      )
+    );
+    process.exit(1);
+  }
+  if (!privateKey.startsWith("0x") || privateKey.length !== 66) {
+    console.error(
+      chalk2.red(
+        "Error: Invalid private key format (must be 0x-prefixed, 66 characters)"
+      )
+    );
+    process.exit(1);
+  }
+  if (options.privateKey) {
+    console.warn(
+      chalk2.yellow(
+        "\u26A0\uFE0F  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
+  };
+}
+async function checkNormalStorageExists(params) {
+  const { storageClient, storageKey, operatorAddress, expectedContent } = params;
+  const existing = await storageClient.get({
+    key: storageKey,
+    operator: operatorAddress
+  });
+  if (!existing) {
+    return { exists: false };
+  }
+  const storedContent = hexToString(existing.value);
+  const matches = storedContent === expectedContent;
+  return { exists: true, matches };
+}
+async function checkChunkedStorageExists(params) {
+  const { storageClient, chunkedHash, operatorAddress } = params;
+  const meta = await storageClient.getChunkedMetadata({
+    key: chunkedHash,
+    operator: operatorAddress
+  });
+  return meta !== null && meta.chunkCount > 0;
+}
+async function checkXmlChunksExist(params) {
+  const { storageClient, chunkedHashes, operatorAddress } = params;
+  const existing = /* @__PURE__ */ new Set();
+  await Promise.all(
+    chunkedHashes.map(async (hash) => {
+      const exists = await checkChunkedStorageExists({
+        storageClient,
+        chunkedHash: hash,
+        operatorAddress
+      });
+      if (exists) {
+        existing.add(hash);
+      }
+    })
+  );
+  return existing;
+}
+async function checkXmlMetadataExists(params) {
+  const { storageClient, storageKey, operatorAddress, expectedMetadata } = params;
+  const existing = await storageClient.get({
+    key: storageKey,
+    operator: operatorAddress
+  });
+  if (!existing) {
+    return { exists: false };
+  }
+  const storedMetadata = hexToString(existing.value);
+  const matches = storedMetadata === expectedMetadata;
+  return { exists: true, matches };
+}
+
+// src/commands/storage/utils.ts
+function typedArgsToArray(args) {
+  if (args.type === "normal" || args.type === "metadata") {
+    return [args.args.key, args.args.text, args.args.value];
+  } else {
+    return [args.args.hash, args.args.text, args.args.chunks];
+  }
+}
+function extractTypedArgsFromTransaction(tx, type) {
+  if (type === "normal" || type === "metadata") {
+    return {
+      type,
+      args: {
+        key: tx.args[0],
+        text: tx.args[1],
+        value: tx.args[2]
+      }
+    };
+  } else {
+    return {
+      type: "chunked",
+      args: {
+        hash: tx.args[0],
+        text: tx.args[1],
+        chunks: tx.args[2]
+      }
+    };
+  }
+}
+function generateStorageUrl(operatorAddress, chainId, storageKey) {
+  if (!operatorAddress) return void 0;
+  return `https://storedon.net/net/${chainId}/storage/load/${operatorAddress}/${encodeStorageKeyForUrl(storageKey)}`;
+}
+async function checkTransactionExists(params) {
+  const { storageClient, tx, operatorAddress } = params;
+  if (tx.type === "normal") {
+    if (tx.typedArgs.type === "normal") {
+      const expectedContent = hexToString(tx.typedArgs.args.value);
+      const check = await checkNormalStorageExists({
+        storageClient,
+        storageKey: tx.id,
+        operatorAddress,
+        expectedContent
+      });
+      return check.exists && check.matches === true;
+    }
+  } else if (tx.type === "chunked") {
+    return await checkChunkedStorageExists({
+      storageClient,
+      chunkedHash: tx.id,
+      operatorAddress
+    });
+  } else if (tx.type === "metadata") {
+    if (tx.typedArgs.type === "metadata") {
+      const expectedMetadata = hexToString(tx.typedArgs.args.value);
+      const check = await checkXmlMetadataExists({
+        storageClient,
+        storageKey: tx.id,
+        operatorAddress,
+        expectedMetadata
+      });
+      return check.exists && check.matches === true;
+    }
+  }
+  return false;
+}
+
+// src/commands/storage/transactions/prep.ts
+function prepareNormalStorageTransaction(storageClient, args, originalStorageKey) {
+  const content = hexToString(args.value);
+  const transaction = storageClient.preparePut({
+    key: originalStorageKey,
+    text: args.text,
+    value: content
+  });
+  const typedArgs = {
+    type: "normal",
+    args
+  };
+  return {
+    id: args.key,
+    type: "normal",
+    transaction,
+    typedArgs
+  };
+}
+function prepareXmlStorageTransactions(params) {
+  const { storageClient, storageKey, text, content, operatorAddress } = params;
+  const storageKeyBytes = getStorageKeyBytes(storageKey);
+  const result = storageClient.prepareXmlStorage({
+    data: content,
+    operatorAddress,
+    storageKey,
+    // Pass as string, not bytes32
+    filename: text,
+    useChunkedStorageBackend: true
+    // Use ChunkedStorage backend (default)
+  });
+  const transactions = result.transactionConfigs.map(
+    (tx, index) => {
+      if (index === 0) {
+        const typedArgs = extractTypedArgsFromTransaction(tx, "metadata");
+        return {
+          id: storageKeyBytes,
+          type: "metadata",
+          transaction: tx,
+          typedArgs
+        };
+      } else {
+        const typedArgs = extractTypedArgsFromTransaction(tx, "chunked");
+        if (typedArgs.type === "chunked") {
+          const chunkedHash = typedArgs.args.hash;
+          return {
+            id: chunkedHash,
+            type: "chunked",
+            transaction: tx,
+            typedArgs
+          };
+        }
+        throw new Error("Invalid chunked transaction");
+      }
+    }
+  );
+  return transactions;
+}
+async function filterExistingTransactions(params) {
+  const { storageClient, transactions, operatorAddress, expectedContent } = params;
+  const toSend = [];
+  const skipped = [];
+  for (const tx of transactions) {
+    let exists = false;
+    if (tx.type === "normal") {
+      if (expectedContent) {
+        const check = await checkNormalStorageExists({
+          storageClient,
+          storageKey: tx.id,
+          operatorAddress,
+          expectedContent
+        });
+        exists = check.exists && check.matches === true;
+      } else {
+        if (tx.typedArgs.type === "normal") {
+          const storedContent = hexToString(tx.typedArgs.args.value);
+          const check = await checkNormalStorageExists({
+            storageClient,
+            storageKey: tx.id,
+            operatorAddress,
+            expectedContent: storedContent
+          });
+          exists = check.exists && check.matches === true;
+        }
+      }
+    } else if (tx.type === "chunked") {
+      exists = await checkChunkedStorageExists({
+        storageClient,
+        chunkedHash: tx.id,
+        operatorAddress
+      });
+    } else if (tx.type === "metadata") {
+      if (tx.typedArgs.type === "metadata") {
+        const expectedMetadata = hexToString(tx.typedArgs.args.value);
+        const check = await checkXmlMetadataExists({
+          storageClient,
+          storageKey: tx.id,
+          operatorAddress,
+          expectedMetadata
+        });
+        exists = check.exists && check.matches === true;
+      }
+    }
+    if (exists) {
+      skipped.push(tx);
+    } else {
+      toSend.push(tx);
+    }
+  }
+  return { toSend, skipped };
+}
+async function filterXmlStorageTransactions(params) {
+  const { storageClient, transactions, operatorAddress } = params;
+  const metadataTx = transactions.find(
+    (tx) => tx.to.toLowerCase() === STORAGE_CONTRACT.address.toLowerCase()
+  );
+  const chunkTxs = transactions.filter(
+    (tx) => tx.to.toLowerCase() === CHUNKED_STORAGE_CONTRACT.address.toLowerCase()
+  );
+  const chunkedHashes = [];
+  for (const tx of chunkTxs) {
+    const typedArgs = extractTypedArgsFromTransaction(tx, "chunked");
+    if (typedArgs.type === "chunked") {
+      chunkedHashes.push(typedArgs.args.hash);
+    }
+  }
+  const toSend = [];
+  const skipped = [];
+  const existingChunks = await checkXmlChunksExist({
+    storageClient,
+    chunkedHashes,
+    operatorAddress
+  });
+  for (const tx of chunkTxs) {
+    const typedArgs = extractTypedArgsFromTransaction(tx, "chunked");
+    if (typedArgs.type === "chunked") {
+      const hash = typedArgs.args.hash;
+      if (existingChunks.has(hash)) {
+        skipped.push(tx);
+      } else {
+        toSend.push(tx);
+      }
+    }
+  }
+  if (metadataTx) {
+    const allChunksExist = chunkedHashes.length > 0 && chunkedHashes.every(
+      (hash) => existingChunks.has(hash)
+    );
+    if (allChunksExist) {
+      try {
+        const typedArgs = extractTypedArgsFromTransaction(metadataTx, "metadata");
+        if (typedArgs.type === "metadata") {
+          const expectedMetadata = hexToString(typedArgs.args.value);
+          const check = await checkXmlMetadataExists({
+            storageClient,
+            storageKey: typedArgs.args.key,
+            operatorAddress,
+            expectedMetadata
+          });
+          if (check.exists && check.matches) {
+            skipped.push(metadataTx);
+          } else {
+            toSend.unshift(metadataTx);
+          }
+        }
+      } catch {
+        toSend.unshift(metadataTx);
+      }
+    } else {
+      toSend.unshift(metadataTx);
+    }
+  }
+  return { toSend, skipped };
+}
+function createWalletClientFromPrivateKey(params) {
+  const { privateKey, chainId, rpcUrl } = params;
+  const account = privateKeyToAccount(privateKey);
+  const publicClient = getPublicClient({ chainId, rpcUrl });
+  const rpcUrls = getChainRpcUrls({ chainId, rpcUrl });
+  const chain = publicClient.chain ? defineChain({
+    id: chainId,
+    name: publicClient.chain.name,
+    nativeCurrency: publicClient.chain.nativeCurrency,
+    rpcUrls: {
+      default: { http: rpcUrls },
+      public: { http: rpcUrls }
+    },
+    blockExplorers: publicClient.chain.blockExplorers
+  }) : defineChain({
+    id: chainId,
+    name: `Chain ${chainId}`,
+    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
+    rpcUrls: {
+      default: { http: rpcUrls },
+      public: { http: rpcUrls }
+    }
+  });
+  const walletClient = createWalletClient({
+    account,
+    chain,
+    transport: http()
+  });
+  return {
+    walletClient,
+    publicClient,
+    operatorAddress: account.address
+  };
+}
+async function sendTransactionsWithIdempotency(params) {
+  const { storageClient, walletClient, publicClient, transactions, operatorAddress } = params;
+  let sent = 0;
+  let skipped = 0;
+  let failed = 0;
+  let finalHash;
+  const errorMessages = [];
+  for (let i = 0; i < transactions.length; i++) {
+    const tx = transactions[i];
+    try {
+      const exists = await checkTransactionExists({
+        storageClient,
+        tx,
+        operatorAddress
+      });
+      if (exists) {
+        console.log(
+          `\u23ED\uFE0F  Transaction ${i + 1}/${transactions.length} skipped (already stored): ${tx.id}`
+        );
+        skipped++;
+        continue;
+      }
+      console.log(
+        `\u{1F4E4} Sending transaction ${i + 1}/${transactions.length}: ${tx.id}`
+      );
+      const args = typedArgsToArray(tx.typedArgs);
+      if (!walletClient.account) {
+        throw new Error("Wallet client must have an account");
+      }
+      const hash = await walletClient.writeContract({
+        account: walletClient.account,
+        address: tx.transaction.to,
+        abi: tx.transaction.abi,
+        functionName: tx.transaction.functionName,
+        args,
+        value: tx.transaction.value,
+        chain: null
+      });
+      const receipt = await publicClient.waitForTransactionReceipt({ hash });
+      console.log(
+        `\u2713 Transaction ${i + 1} confirmed in block ${receipt.blockNumber} (hash: ${hash})`
+      );
+      sent++;
+      finalHash = hash;
+    } catch (error) {
+      const errorMsg = error instanceof Error ? error.message : String(error);
+      console.error(`\u2717 Transaction ${i + 1} failed: ${errorMsg}`);
+      errorMessages.push(errorMsg);
+      failed++;
+    }
+  }
+  return {
+    success: failed === 0,
+    skipped: skipped > 0,
+    transactionsSent: sent,
+    transactionsSkipped: skipped,
+    transactionsFailed: failed,
+    finalHash,
+    error: errorMessages.length > 0 ? errorMessages.join("; ") : void 0
+  };
+}
+
+// src/commands/storage/core/upload.ts
+async function uploadFile(options) {
+  const fileBuffer = readFileSync(options.filePath);
+  const isBinary = fileBuffer.some(
+    (byte) => byte === 0 || byte < 32 && byte !== 9 && byte !== 10 && byte !== 13
+  );
+  let fileContent;
+  if (isBinary) {
+    const base64String = fileBuffer.toString("base64");
+    const detectedType = detectFileTypeFromBase64(base64String);
+    if (detectedType) {
+      fileContent = base64ToDataUri(base64String);
+    } else {
+      fileContent = base64String;
+    }
+  } else {
+    fileContent = fileBuffer.toString("utf-8");
+  }
+  const storageClient = new StorageClient({
+    chainId: options.chainId,
+    overrides: options.rpcUrl ? { rpcUrls: [options.rpcUrl] } : void 0
+  });
+  const { walletClient, publicClient, operatorAddress } = createWalletClientFromPrivateKey({
+    privateKey: options.privateKey,
+    chainId: options.chainId,
+    rpcUrl: options.rpcUrl
+  });
+  const useXmlStorage = shouldSuggestXmlStorage(fileContent);
+  const storageType = useXmlStorage ? "xml" : "normal";
+  let transactions;
+  if (useXmlStorage) {
+    transactions = prepareXmlStorageTransactions({
+      storageClient,
+      storageKey: options.storageKey,
+      text: options.text,
+      content: fileContent,
+      operatorAddress
+    });
+  } else {
+    const storageKeyBytes = getStorageKeyBytes(
+      options.storageKey
+    );
+    const typedArgs = {
+      key: storageKeyBytes,
+      text: options.text,
+      value: stringToHex(fileContent)
+    };
+    transactions = [
+      prepareNormalStorageTransaction(
+        storageClient,
+        typedArgs,
+        options.storageKey
+        // Pass original string key for preparePut
+      )
+    ];
+  }
+  let transactionsToSend;
+  let skippedCount = 0;
+  if (useXmlStorage) {
+    const chunkTransactions = transactions.filter((tx) => tx.type === "chunked").map((tx) => tx.transaction);
+    const txConfigToTxWithId = new Map(
+      transactions.filter((tx) => tx.type === "chunked").map((tx) => [tx.transaction, tx])
+    );
+    const filtered = await filterXmlStorageTransactions({
+      storageClient,
+      transactions: chunkTransactions,
+      // Only chunk transactions
+      operatorAddress
+    });
+    const filteredToSend = filtered.toSend.map((txConfig) => txConfigToTxWithId.get(txConfig)).filter((tx) => tx !== void 0);
+    const filteredSkipped = filtered.skipped.map((txConfig) => txConfigToTxWithId.get(txConfig)).filter((tx) => tx !== void 0);
+    const metadataTx = transactions.find((tx) => tx.type === "metadata");
+    if (metadataTx) {
+      filteredToSend.unshift(metadataTx);
+    }
+    transactionsToSend = filteredToSend;
+    skippedCount = filteredSkipped.length;
+  } else {
+    const filtered = await filterExistingTransactions({
+      storageClient,
+      transactions,
+      operatorAddress,
+      expectedContent: fileContent
+    });
+    transactionsToSend = filtered.toSend;
+    skippedCount = filtered.skipped.length;
+  }
+  if (transactionsToSend.length === 0) {
+    return {
+      success: true,
+      skipped: true,
+      transactionsSent: 0,
+      transactionsSkipped: skippedCount,
+      transactionsFailed: 0,
+      operatorAddress,
+      storageType
+    };
+  }
+  const result = await sendTransactionsWithIdempotency({
+    storageClient,
+    walletClient,
+    publicClient,
+    transactions: transactionsToSend,
+    operatorAddress
+  });
+  result.transactionsSkipped += skippedCount;
+  result.operatorAddress = operatorAddress;
+  result.storageType = storageType;
+  return result;
+}
+
+// src/commands/storage/relay/recheckStorage.ts
+async function recheckFailedTransactionsStorage(failedIndexes, transactions, storageClient, backendWalletAddress) {
+  if (failedIndexes.length === 0) {
+    return [];
+  }
+  const failedTransactions = failedIndexes.map((idx) => transactions[idx]);
+  const chunkedHashes = [];
+  for (const tx of failedTransactions) {
+    try {
+      const typedArgs = extractTypedArgsFromTransaction(tx, "chunked");
+      if (typedArgs.type === "chunked") {
+        chunkedHashes.push(typedArgs.args.hash);
+      }
+    } catch {
+    }
+  }
+  if (chunkedHashes.length === 0) {
+    return failedIndexes;
+  }
+  const existingChunks = await checkXmlChunksExist({
+    storageClient,
+    chunkedHashes,
+    operatorAddress: backendWalletAddress
+  });
+  const stillFailed = [];
+  for (const failedIdx of failedIndexes) {
+    const tx = transactions[failedIdx];
+    try {
+      const typedArgs = extractTypedArgsFromTransaction(tx, "chunked");
+      if (typedArgs.type === "chunked") {
+        const hash = typedArgs.args.hash;
+        if (!existingChunks.has(hash)) {
+          stillFailed.push(failedIdx);
+        }
+      } else {
+        stillFailed.push(failedIdx);
+      }
+    } catch {
+      stillFailed.push(failedIdx);
+    }
+  }
+  return stillFailed;
+}
+
+// src/commands/storage/relay/retry.ts
+async function retryFailedTransactions(params) {
+  const {
+    storageClient,
+    backendWalletAddress,
+    apiUrl,
+    chainId,
+    operatorAddress,
+    secretKey,
+    failedIndexes,
+    originalTransactions,
+    config,
+    sessionToken
+  } = params;
+  return retryFailedTransactions$1({
+    apiUrl,
+    chainId,
+    operatorAddress,
+    secretKey,
+    failedIndexes,
+    originalTransactions,
+    backendWalletAddress,
+    config,
+    sessionToken,
+    recheckFunction: async (failedIndexes2, transactions, backendWalletAddress2) => {
+      return recheckFailedTransactionsStorage(
+        failedIndexes2,
+        transactions,
+        storageClient,
+        backendWalletAddress2
+      );
+    }
+  });
+}
+
+// src/commands/storage/core/uploadRelay.ts
+async function uploadFileWithRelay(options) {
+  const errors = [];
+  const fileBuffer = readFileSync(options.filePath);
+  const isBinary = fileBuffer.some(
+    (byte) => byte === 0 || byte < 32 && byte !== 9 && byte !== 10 && byte !== 13
+  );
+  let fileContent;
+  if (isBinary) {
+    const base64String = fileBuffer.toString("base64");
+    const detectedType = detectFileTypeFromBase64(base64String);
+    if (detectedType) {
+      fileContent = base64ToDataUri(base64String);
+    } else {
+      fileContent = base64String;
+    }
+  } else {
+    fileContent = fileBuffer.toString("utf-8");
+  }
+  const storageClient = new StorageClient({
+    chainId: options.chainId,
+    overrides: options.rpcUrl ? { rpcUrls: [options.rpcUrl] } : void 0
+  });
+  const userAccount = privateKeyToAccount(options.privateKey);
+  const userAddress = userAccount.address;
+  const publicClient = getPublicClient({
+    chainId: options.chainId,
+    rpcUrl: options.rpcUrl
+  });
+  const rpcUrls = getChainRpcUrls({
+    chainId: options.chainId,
+    rpcUrl: options.rpcUrl
+  });
+  const userWalletClient = createWalletClient({
+    account: userAccount,
+    chain: publicClient.chain,
+    transport: http(rpcUrls[0])
+    // Use first RPC URL
+  });
+  const { fetchWithPayment, httpClient } = createRelayX402Client(
+    userAccount,
+    options.chainId
+  );
+  const sessionResult = await createRelaySession({
+    apiUrl: options.apiUrl,
+    chainId: options.chainId,
+    operatorAddress: userAddress,
+    secretKey: options.secretKey,
+    account: userAccount,
+    expiresIn: 3600
+    // 1 hour - should be enough for most uploads
+  });
+  const sessionToken = sessionResult.sessionToken;
+  console.log("\u2713 Session token created (valid for 1 hour)");
+  let backendWalletAddress;
+  let shouldFund = true;
+  try {
+    const balanceResult = await checkBackendWalletBalance({
+      apiUrl: options.apiUrl,
+      chainId: options.chainId,
+      operatorAddress: userAddress,
+      secretKey: options.secretKey
+    });
+    backendWalletAddress = balanceResult.backendWalletAddress;
+    shouldFund = !balanceResult.sufficientBalance;
+  } catch (error) {
+    shouldFund = true;
+  }
+  if (shouldFund) {
+    const fundResult = await fundBackendWallet({
+      apiUrl: options.apiUrl,
+      chainId: options.chainId,
+      operatorAddress: userAddress,
+      secretKey: options.secretKey,
+      fetchWithPayment,
+      httpClient
+    });
+    backendWalletAddress = fundResult.backendWalletAddress;
+  }
+  if (!backendWalletAddress) {
+    throw new Error("Failed to determine backend wallet address");
+  }
+  const chunkPrepareResult = storageClient.prepareXmlStorage({
+    data: fileContent,
+    operatorAddress: backendWalletAddress,
+    storageKey: options.storageKey,
+    filename: options.text,
+    useChunkedStorageBackend: true
+  });
+  const chunkTxs = chunkPrepareResult.transactionConfigs.slice(1);
+  const topLevelHash = chunkPrepareResult.topLevelHash;
+  const chunkMetadata = chunkPrepareResult.metadata;
+  const metadataTx = storageClient.preparePut({
+    key: topLevelHash,
+    text: options.text,
+    value: chunkMetadata
+    // Use the XML metadata from chunk preparation
+  });
+  const filteredChunks = await filterXmlStorageTransactions({
+    storageClient,
+    transactions: chunkTxs,
+    operatorAddress: backendWalletAddress
+  });
+  const chunksToSend = filteredChunks.toSend;
+  const chunksSkipped = filteredChunks.skipped.length;
+  const metadataStorageKey = metadataTx.args[0];
+  const expectedMetadata = hexToString(metadataTx.args[2]);
+  let metadataNeedsSubmission = true;
+  const metadataCheck = await checkXmlMetadataExists({
+    storageClient,
+    storageKey: metadataStorageKey,
+    operatorAddress: userAddress,
+    // User is operator for metadata
+    expectedMetadata
+  });
+  if (metadataCheck.exists && metadataCheck.matches) {
+    metadataNeedsSubmission = false;
+  }
+  let chunkTransactionHashes = [];
+  let chunksSent = 0;
+  if (chunksToSend.length > 0) {
+    try {
+      const batches = batchTransactions(chunksToSend);
+      const totalBatches = batches.length;
+      if (totalBatches > 1) {
+        console.log(
+          `\u{1F4E6} Splitting ${chunksToSend.length} chunks into ${totalBatches} batch(es)`
+        );
+      }
+      for (let batchIndex = 0; batchIndex < batches.length; batchIndex++) {
+        const batch = batches[batchIndex];
+        if (totalBatches > 1) {
+          console.log(
+            `\u{1F4E4} Sending batch ${batchIndex + 1}/${totalBatches} (${batch.length} transactions)...`
+          );
+        }
+        const submitResult = await submitTransactionsViaRelay({
+          apiUrl: options.apiUrl,
+          chainId: options.chainId,
+          operatorAddress: userAddress,
+          secretKey: options.secretKey,
+          transactions: batch,
+          sessionToken
+        });
+        chunkTransactionHashes.push(...submitResult.transactionHashes);
+        chunksSent += submitResult.successfulIndexes.length;
+        if (submitResult.failedIndexes.length === batch.length) {
+          const errorMessage = `Batch ${batchIndex + 1}: All ${batch.length} transactions failed. Likely due to insufficient backend wallet balance or network issues. Stopping batch processing to avoid wasting app fees.`;
+          console.error(`\u274C ${errorMessage}`);
+          errors.push(new Error(errorMessage));
+          break;
+        }
+        if (submitResult.failedIndexes.length > 0 && submitResult.successfulIndexes.length > 0) {
+          const failedTxs = submitResult.failedIndexes.map((idx) => batch[idx]);
+          try {
+            const retryResult = await retryFailedTransactions({
+              apiUrl: options.apiUrl,
+              chainId: options.chainId,
+              operatorAddress: userAddress,
+              secretKey: options.secretKey,
+              failedIndexes: submitResult.failedIndexes,
+              originalTransactions: failedTxs,
+              storageClient,
+              backendWalletAddress,
+              sessionToken
+            });
+            chunkTransactionHashes.push(...retryResult.transactionHashes);
+            chunksSent += retryResult.successfulIndexes.length;
+            if (retryResult.failedIndexes.length > 0) {
+              errors.push(
+                new Error(
+                  `Batch ${batchIndex + 1}: ${retryResult.failedIndexes.length} transactions failed after retries`
+                )
+              );
+            }
+          } catch (retryError) {
+            errors.push(
+              retryError instanceof Error ? retryError : new Error(
+                `Batch ${batchIndex + 1} retry failed: ${String(
+                  retryError
+                )}`
+              )
+            );
+          }
+        }
+        if (batchIndex < batches.length - 1 && chunkTransactionHashes.length > 0) {
+          const batchHashes = chunkTransactionHashes.slice(
+            -submitResult.successfulIndexes.length
+          );
+          if (batchHashes.length > 0) {
+            try {
+              await waitForConfirmations({
+                publicClient,
+                transactionHashes: batchHashes,
+                confirmations: 1,
+                // Just 1 confirmation between batches
+                timeout: 3e4
+                // 30 second timeout per batch
+              });
+            } catch (confirmationError) {
+              console.warn(
+                `\u26A0\uFE0F  Batch ${batchIndex + 1} confirmation timeout (continuing...)`
+              );
+            }
+          }
+        }
+      }
+    } catch (submitError) {
+      errors.push(
+        submitError instanceof Error ? submitError : new Error(`Chunk submission failed: ${String(submitError)}`)
+      );
+    }
+  }
+  if (chunkTransactionHashes.length > 0) {
+    try {
+      await waitForConfirmations({
+        publicClient,
+        transactionHashes: chunkTransactionHashes,
+        confirmations: 1,
+        timeout: 6e4
+      });
+    } catch (confirmationError) {
+      errors.push(
+        confirmationError instanceof Error ? confirmationError : new Error(`Chunk confirmation failed: ${String(confirmationError)}`)
+      );
+    }
+  }
+  let metadataTransactionHash;
+  if (metadataNeedsSubmission) {
+    try {
+      metadataTransactionHash = await userWalletClient.writeContract({
+        address: metadataTx.to,
+        abi: metadataTx.abi,
+        functionName: metadataTx.functionName,
+        args: metadataTx.args,
+        value: metadataTx.value !== void 0 && metadataTx.value > BigInt(0) ? metadataTx.value : void 0
+      });
+      await waitForConfirmations({
+        publicClient,
+        transactionHashes: [metadataTransactionHash],
+        confirmations: 1,
+        timeout: 6e4
+      });
+    } catch (metadataError) {
+      errors.push(
+        metadataError instanceof Error ? metadataError : new Error(`Metadata submission failed: ${String(metadataError)}`)
+      );
+    }
+  }
+  return {
+    success: errors.length === 0,
+    topLevelHash,
+    chunksSent,
+    chunksSkipped,
+    metadataSubmitted: metadataNeedsSubmission && metadataTransactionHash !== void 0,
+    chunkTransactionHashes,
+    metadataTransactionHash,
+    backendWalletAddress,
+    errors: errors.length > 0 ? errors : void 0
+  };
+}
+async function previewFile(options) {
+  const fileBuffer = readFileSync(options.filePath);
+  const isBinary = fileBuffer.some(
+    (byte) => byte === 0 || byte < 32 && byte !== 9 && byte !== 10 && byte !== 13
+  );
+  let fileContent;
+  if (isBinary) {
+    const base64String = fileBuffer.toString("base64");
+    const detectedType = detectFileTypeFromBase64(base64String);
+    if (detectedType) {
+      fileContent = base64ToDataUri(base64String);
+    } else {
+      fileContent = base64String;
+    }
+  } else {
+    fileContent = fileBuffer.toString("utf-8");
+  }
+  const storageClient = new StorageClient({
+    chainId: options.chainId,
+    overrides: options.rpcUrl ? { rpcUrls: [options.rpcUrl] } : void 0
+  });
+  const { operatorAddress } = createWalletClientFromPrivateKey({
+    privateKey: options.privateKey,
+    chainId: options.chainId,
+    rpcUrl: options.rpcUrl
+  });
+  const useXmlStorage = shouldSuggestXmlStorage(fileContent);
+  let transactions;
+  if (useXmlStorage) {
+    transactions = prepareXmlStorageTransactions({
+      storageClient,
+      storageKey: options.storageKey,
+      text: options.text,
+      content: fileContent,
+      operatorAddress
+    });
+  } else {
+    const storageKeyBytes = getStorageKeyBytes(
+      options.storageKey
+    );
+    const typedArgs = {
+      key: storageKeyBytes,
+      text: options.text,
+      value: stringToHex(fileContent)
+    };
+    transactions = [
+      prepareNormalStorageTransaction(
+        storageClient,
+        typedArgs,
+        options.storageKey
+        // Pass original string key for preparePut
+      )
+    ];
+  }
+  let transactionsToSend;
+  let transactionsSkipped;
+  if (useXmlStorage) {
+    const chunkTransactions = transactions.filter((tx) => tx.type === "chunked").map((tx) => tx.transaction);
+    const txConfigToTxWithId = new Map(
+      transactions.filter((tx) => tx.type === "chunked").map((tx) => [tx.transaction, tx])
+    );
+    const filtered = await filterXmlStorageTransactions({
+      storageClient,
+      transactions: chunkTransactions,
+      // Only chunk transactions
+      operatorAddress
+    });
+    const filteredToSend = filtered.toSend.map((txConfig) => txConfigToTxWithId.get(txConfig)).filter((tx) => tx !== void 0);
+    const filteredSkipped = filtered.skipped.map((txConfig) => txConfigToTxWithId.get(txConfig)).filter((tx) => tx !== void 0);
+    const metadataTx = transactions.find((tx) => tx.type === "metadata");
+    if (metadataTx) {
+      filteredToSend.unshift(metadataTx);
+    }
+    transactionsToSend = filteredToSend;
+    transactionsSkipped = filteredSkipped;
+  } else {
+    const filtered = await filterExistingTransactions({
+      storageClient,
+      transactions,
+      operatorAddress,
+      expectedContent: fileContent
+    });
+    transactionsToSend = filtered.toSend;
+    transactionsSkipped = filtered.skipped;
+  }
+  if (useXmlStorage) {
+    const chunkTransactions = transactions.filter(
+      (tx) => tx.type === "chunked"
+    );
+    const metadataTransaction = transactions.find(
+      (tx) => tx.type === "metadata"
+    );
+    const totalChunks = chunkTransactions.length;
+    const alreadyStoredChunks = transactionsSkipped.filter(
+      (tx) => tx.type === "chunked"
+    ).length;
+    const needToStoreChunks = transactionsToSend.filter(
+      (tx) => tx.type === "chunked"
+    ).length;
+    const metadataNeedsStorage = metadataTransaction ? transactionsToSend.some((tx) => tx.type === "metadata") : false;
+    return {
+      storageType: "xml",
+      totalChunks,
+      alreadyStoredChunks,
+      needToStoreChunks,
+      metadataNeedsStorage,
+      operatorAddress,
+      storageKey: options.storageKey,
+      totalTransactions: transactions.length,
+      transactionsToSend: transactionsToSend.length,
+      transactionsSkipped: transactionsSkipped.length
+    };
+  } else {
+    const totalChunks = 1;
+    const alreadyStoredChunks = transactionsSkipped.length;
+    const needToStoreChunks = transactionsToSend.length;
+    return {
+      storageType: "normal",
+      totalChunks,
+      alreadyStoredChunks,
+      needToStoreChunks,
+      operatorAddress,
+      storageKey: options.storageKey,
+      totalTransactions: transactions.length,
+      transactionsToSend: transactionsToSend.length,
+      transactionsSkipped: transactionsSkipped.length
+    };
+  }
+}
+
+// src/commands/storage/index.ts
+function registerStorageCommand(program2) {
+  const storageCommand = program2.command("storage").description("Storage operations");
+  const uploadCommand = new Command("upload").description("Upload files to Net Storage").requiredOption("--file <path>", "Path to file to upload").requiredOption("--key <key>", "Storage key (filename/identifier)").requiredOption("--text <text>", "Text description/filename").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 (8453 for Base, 1 for Ethereum, etc.). 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)"
+  ).action(async (options) => {
+    const commonOptions = parseCommonOptions({
+      privateKey: options.privateKey,
+      chainId: options.chainId,
+      rpcUrl: options.rpcUrl
+    });
+    const uploadOptions = {
+      filePath: options.file,
+      storageKey: options.key,
+      text: options.text,
+      privateKey: commonOptions.privateKey,
+      chainId: commonOptions.chainId,
+      rpcUrl: commonOptions.rpcUrl
+    };
+    try {
+      console.log(chalk2.blue(`\u{1F4C1} Reading file: ${options.file}`));
+      const result = await uploadFile(uploadOptions);
+      const storageUrl = generateStorageUrl(
+        result.operatorAddress,
+        commonOptions.chainId,
+        options.key
+      );
+      if (result.skipped && result.transactionsSent === 0) {
+        console.log(
+          chalk2.green(
+            `\u2713 All data already stored - skipping upload
+  Storage Key: ${options.key}
+  Skipped: ${result.transactionsSkipped} transaction(s)${storageUrl ? `
+  Storage URL: ${chalk2.cyan(storageUrl)}` : ""}`
+          )
+        );
+        process.exit(0);
+      }
+      if (result.success) {
+        console.log(
+          chalk2.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)}` : ""}`
+          )
+        );
+        process.exit(0);
+      } else {
+        console.error(
+          chalk2.red(
+            `\u2717 Upload completed with errors
+  Transactions Sent: ${result.transactionsSent}
+  Transactions Skipped: ${result.transactionsSkipped}
+  Transactions Failed: ${result.transactionsFailed}
+  Error: ${result.error || "Unknown error"}`
+          )
+        );
+        process.exit(1);
+      }
+    } catch (error) {
+      console.error(
+        chalk2.red(
+          `Upload failed: ${error instanceof Error ? error.message : String(error)}`
+        )
+      );
+      process.exit(1);
+    }
+  });
+  const previewCommand = new Command("preview").description("Preview storage upload without submitting transactions").requiredOption("--file <path>", "Path to file to preview").requiredOption("--key <key>", "Storage key (filename/identifier)").requiredOption("--text <text>", "Text description/filename").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 (8453 for Base, 1 for Ethereum, etc.). 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)"
+  ).action(async (options) => {
+    const commonOptions = parseCommonOptions({
+      privateKey: options.privateKey,
+      chainId: options.chainId,
+      rpcUrl: options.rpcUrl
+    });
+    const previewOptions = {
+      filePath: options.file,
+      storageKey: options.key,
+      text: options.text,
+      privateKey: commonOptions.privateKey,
+      chainId: commonOptions.chainId,
+      rpcUrl: commonOptions.rpcUrl
+    };
+    try {
+      console.log(chalk2.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(
+        `  Storage Type: ${chalk2.white(
+          result.storageType === "xml" ? "XML" : "Normal"
+        )}`
+      );
+      console.log(`  Total Chunks: ${chalk2.white(result.totalChunks)}`);
+      console.log(
+        `  Already Stored: ${chalk2.green(result.alreadyStoredChunks)}`
+      );
+      console.log(
+        `  Need to Store: ${chalk2.yellow(result.needToStoreChunks)}`
+      );
+      if (result.storageType === "xml" && result.metadataNeedsStorage) {
+        console.log(`  Metadata: ${chalk2.yellow("Needs Storage")}`);
+      } else if (result.storageType === "xml") {
+        console.log(`  Metadata: ${chalk2.green("Already Stored")}`);
+      }
+      console.log(
+        `  Total Transactions: ${chalk2.white(result.totalTransactions)}`
+      );
+      console.log(
+        `  Transactions to Send: ${chalk2.yellow(result.transactionsToSend)}`
+      );
+      console.log(
+        `  Transactions Skipped: ${chalk2.green(result.transactionsSkipped)}`
+      );
+      console.log(
+        `  Operator Address: ${chalk2.gray(result.operatorAddress)}`
+      );
+      if (storageUrl) {
+        console.log(`  Storage URL: ${chalk2.cyan(storageUrl)}`);
+      }
+      if (result.needToStoreChunks === 0 && !result.metadataNeedsStorage) {
+        console.log(
+          chalk2.green("\n\u2713 All data is already stored - no upload needed")
+        );
+      } else {
+        console.log(
+          chalk2.yellow(
+            `
+\u26A0 ${result.transactionsToSend} transaction(s) would be sent`
+          )
+        );
+      }
+      process.exit(0);
+    } catch (error) {
+      console.error(
+        chalk2.red(
+          `Preview failed: ${error instanceof Error ? error.message : String(error)}`
+        )
+      );
+      process.exit(1);
+    }
+  });
+  const uploadRelayCommand = new Command("upload-relay").description("Upload files to Net Storage via x402 relay (backend pays gas for chunks)").requiredOption("--file <path>", "Path to file to upload").requiredOption("--key <key>", "Storage key (filename/identifier)").requiredOption("--text <text>", "Text description/filename").requiredOption(
+    "--api-url <url>",
+    "Backend API URL (e.g., http://localhost:3000)"
+  ).requiredOption(
+    "--secret-key <key>",
+    "Secret key for backend wallet derivation. Can also be set via X402_SECRET_KEY env var"
+  ).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 (8453 for Base, 1 for Ethereum, etc.). 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)"
+  ).action(async (options) => {
+    const commonOptions = parseCommonOptions({
+      privateKey: options.privateKey,
+      chainId: options.chainId,
+      rpcUrl: options.rpcUrl
+    });
+    const secretKey = options.secretKey || process.env.X402_SECRET_KEY;
+    if (!secretKey) {
+      console.error(
+        chalk2.red(
+          "Error: --secret-key is required or set X402_SECRET_KEY environment variable"
+        )
+      );
+      process.exit(1);
+    }
+    const uploadRelayOptions = {
+      filePath: options.file,
+      storageKey: options.key,
+      text: options.text,
+      privateKey: commonOptions.privateKey,
+      chainId: commonOptions.chainId,
+      rpcUrl: commonOptions.rpcUrl,
+      apiUrl: options.apiUrl,
+      secretKey
+    };
+    try {
+      console.log(chalk2.blue(`\u{1F4C1} Reading file: ${options.file}`));
+      console.log(chalk2.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 storageUrl = generateStorageUrl(
+        userAccount.address,
+        commonOptions.chainId,
+        options.key
+      );
+      if (result.success) {
+        console.log(
+          chalk2.green(
+            `\u2713 File uploaded successfully via relay!
+  Storage Key: ${options.key}
+  Top-Level Hash: ${result.topLevelHash}
+  Chunks Sent: ${result.chunksSent}
+  Chunks Skipped: ${result.chunksSkipped}
+  Metadata Submitted: ${result.metadataSubmitted ? "Yes" : "No (already exists)"}
+  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)}` : ""}`
+          )
+        );
+        process.exit(0);
+      } else {
+        console.error(
+          chalk2.red(
+            `\u2717 Upload completed with errors
+  Chunks Sent: ${result.chunksSent}
+  Chunks Skipped: ${result.chunksSkipped}
+  Metadata Submitted: ${result.metadataSubmitted ? "Yes" : "No"}
+  Errors: ${result.errors ? result.errors.map((e) => e.message).join(", ") : "Unknown error"}`
+          )
+        );
+        process.exit(1);
+      }
+    } catch (error) {
+      console.error(
+        chalk2.red(
+          `Upload via relay failed: ${error instanceof Error ? error.message : String(error)}`
+        )
+      );
+      process.exit(1);
+    }
+  });
+  storageCommand.addCommand(uploadCommand);
+  storageCommand.addCommand(previewCommand);
+  storageCommand.addCommand(uploadRelayCommand);
+}
+
+// src/cli/index.ts
+var program = new Command();
+program.name("netp").description("CLI tool for Net Protocol").version("0.1.0");
+registerStorageCommand(program);
+program.parse();
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map