@sip-protocol/cli 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 RECTOR Labs
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,175 @@
+# @sip-protocol/cli
+
+Command-line tool for Shielded Intents Protocol (SIP) operations.
+
+## Installation
+
+```bash
+npm install -g @sip-protocol/cli
+```
+
+Or use directly with npx:
+
+```bash
+npx @sip-protocol/cli --help
+```
+
+## Commands
+
+### Initialize Configuration
+
+```bash
+sip init [options]
+
+Options:
+  -n, --network <network>  Network (mainnet|testnet) (default: "testnet")
+  -p, --privacy <level>    Default privacy level (default: "transparent")
+  --reset                  Reset configuration to defaults
+```
+
+### Generate Stealth Meta-Address
+
+```bash
+sip keygen [options]
+
+Options:
+  -c, --chain <chain>        Target chain (ethereum, solana, near) (default: "ethereum")
+  --spending-key <key>       Spending private key (hex)
+  --viewing-key <key>        Viewing private key (hex)
+```
+
+### Create Pedersen Commitment
+
+```bash
+sip commit <amount> [options]
+
+Arguments:
+  amount                    Amount to commit
+
+Options:
+  -b, --blinding <factor>   Blinding factor (hex, optional)
+  --verify                  Verify the commitment after creation
+```
+
+### Generate ZK Proof
+
+```bash
+# Funding proof
+sip prove funding [options]
+
+Options:
+  -b, --balance <amount>    Current balance (required)
+  -m, --minimum <amount>    Minimum required (required)
+  -c, --commitment <hex>    Balance commitment
+
+# Validity proof
+sip prove validity [options]
+
+Options:
+  -i, --intent <hash>       Intent hash (required)
+  -s, --sender <address>    Sender address (required)
+  -c, --commitment <hex>    Amount commitment
+```
+
+### Verify ZK Proof
+
+```bash
+sip verify <proof> [options]
+
+Arguments:
+  proof                     Proof to verify (hex string)
+
+Options:
+  -t, --type <type>         Proof type (funding|validity|fulfillment) (default: "funding")
+  -p, --public-inputs <json> Public inputs (JSON array)
+```
+
+### Get Swap Quote
+
+```bash
+sip quote <from-chain> <to-chain> <amount> [options]
+
+Arguments:
+  from-chain                Source chain (e.g., ethereum, solana)
+  to-chain                  Destination chain
+  amount                    Amount to swap
+
+Options:
+  -t, --token <symbol>      Token symbol (default: native token)
+  -p, --privacy <level>     Privacy level (transparent|shielded|compliant)
+```
+
+### Execute Swap
+
+```bash
+sip swap <from-chain> <to-chain> <amount> [options]
+
+Arguments:
+  from-chain                Source chain (e.g., ethereum, solana)
+  to-chain                  Destination chain
+  amount                    Amount to swap
+
+Options:
+  -t, --token <symbol>      Token symbol (default: native token)
+  -p, --privacy <level>     Privacy level (transparent|shielded|compliant)
+  -r, --recipient <address> Recipient address (optional)
+  --solver <id>             Specific solver to use
+```
+
+### Scan for Stealth Payments
+
+```bash
+sip scan [options]
+
+Options:
+  -c, --chain <chain>       Chain to scan (ethereum, solana, near) (required)
+  -s, --spending-key <key>  Your spending private key (hex) (required)
+  -v, --viewing-key <key>   Your viewing private key (hex) (required)
+  -a, --addresses <addresses...> Specific addresses to check
+```
+
+## Examples
+
+```bash
+# Initialize with testnet
+sip init --network testnet --privacy shielded
+
+# Generate stealth keys for Ethereum
+sip keygen --chain ethereum
+
+# Create commitment
+sip commit 1000000000000000000 --verify
+
+# Generate funding proof
+sip prove funding --balance 5000000 --minimum 1000000
+
+# Get quote for ETH to SOL swap
+sip quote ethereum solana 1000000000000000000 --privacy shielded
+
+# Execute swap
+sip swap ethereum solana 1000000000000000000 --privacy shielded
+
+# Scan for stealth payments
+sip scan --chain ethereum -s 0xYOUR_SPENDING_KEY -v 0xYOUR_VIEWING_KEY -a 0xADDRESS1 0xADDRESS2
+```
+
+## Development
+
+```bash
+# Install dependencies
+pnpm install
+
+# Build
+pnpm build
+
+# Test locally
+node bin/sip.js --help
+
+# Link globally for testing
+npm link
+sip --help
+```
+
+## License
+
+MIT

package/bin/sip.js

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+
+// Import the compiled CLI from dist
+require('../dist/index.js')

package/dist/index.d.mts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/index.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/index.js

@@ -0,0 +1,538 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/index.ts
+var import_commander9 = require("commander");
+
+// src/commands/init.ts
+var import_commander = require("commander");
+var import_types = require("@sip-protocol/types");
+
+// src/utils/config.ts
+var import_conf = __toESM(require("conf"));
+var schema = {
+  network: {
+    type: "string",
+    default: "testnet"
+  },
+  defaultPrivacy: {
+    type: "string",
+    default: "transparent"
+  }
+};
+var store = new import_conf.default({
+  projectName: "sip-protocol",
+  schema
+});
+function getConfig() {
+  return {
+    network: store.get("network"),
+    defaultPrivacy: store.get("defaultPrivacy"),
+    defaultChain: store.get("defaultChain"),
+    rpcEndpoints: store.get("rpcEndpoints")
+  };
+}
+function setConfig(key, value) {
+  store.set(key, value);
+}
+function resetConfig() {
+  store.clear();
+}
+function getConfigPath() {
+  return store.path;
+}
+
+// src/utils/output.ts
+var import_chalk = __toESM(require("chalk"));
+var import_ora = __toESM(require("ora"));
+function success(message) {
+  console.log(import_chalk.default.green("\u2713"), message);
+}
+function error(message) {
+  console.error(import_chalk.default.red("\u2717"), message);
+}
+function warning(message) {
+  console.warn(import_chalk.default.yellow("\u26A0"), message);
+}
+function info(message) {
+  console.log(import_chalk.default.blue("\u2139"), message);
+}
+function heading(message) {
+  console.log(import_chalk.default.bold.cyan(`
+${message}
+`));
+}
+function keyValue(key, value) {
+  console.log(import_chalk.default.gray(`  ${key}:`), import_chalk.default.white(String(value)));
+}
+function spinner(text) {
+  return (0, import_ora.default)(text).start();
+}
+function table(headers, rows) {
+  const colWidths = headers.map(
+    (h, i) => Math.max(h.length, ...rows.map((r) => String(r[i] || "").length))
+  );
+  console.log(
+    headers.map((h, i) => import_chalk.default.bold(h.padEnd(colWidths[i]))).join("  ")
+  );
+  console.log(colWidths.map((w) => "\u2500".repeat(w)).join("  "));
+  rows.forEach((row) => {
+    console.log(
+      row.map((cell, i) => String(cell).padEnd(colWidths[i])).join("  ")
+    );
+  });
+}
+function formatAmount(amount, decimals = 18) {
+  const divisor = 10n ** BigInt(decimals);
+  const integer = amount / divisor;
+  const fraction = amount % divisor;
+  const fractionStr = fraction.toString().padStart(decimals, "0").slice(0, 6);
+  return `${integer}.${fractionStr}`;
+}
+function formatHash(hash, length = 8) {
+  if (hash.length <= length * 2) return hash;
+  return `${hash.slice(0, length)}...${hash.slice(-length)}`;
+}
+
+// src/commands/init.ts
+function createInitCommand() {
+  return new import_commander.Command("init").description("Initialize SIP configuration").option("-n, --network <network>", "Network (mainnet|testnet)", "testnet").option("-p, --privacy <level>", "Default privacy level", "transparent").option("--reset", "Reset configuration to defaults").action(async (options) => {
+    try {
+      heading("Initialize SIP Protocol");
+      if (options.reset) {
+        resetConfig();
+        success("Configuration reset to defaults");
+      }
+      const privacy = options.privacy;
+      if (!Object.values(import_types.PrivacyLevel).includes(privacy)) {
+        throw new Error(`Invalid privacy level: ${privacy}`);
+      }
+      setConfig("network", options.network);
+      setConfig("defaultPrivacy", privacy);
+      success("SIP initialized successfully");
+      info(`Network: ${options.network}`);
+      info(`Default Privacy: ${privacy}`);
+      info(`Config file: ${getConfigPath()}`);
+    } catch (err) {
+      console.error("Failed to initialize:", err);
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/keygen.ts
+var import_commander2 = require("commander");
+var import_sdk = require("@sip-protocol/sdk");
+function createKeygenCommand() {
+  return new import_commander2.Command("keygen").description("Generate stealth meta-address").option("-c, --chain <chain>", "Target chain (ethereum, solana, near)", "ethereum").option("--spending-key <key>", "Spending private key (hex)").option("--viewing-key <key>", "Viewing private key (hex)").action(async (options) => {
+    try {
+      heading("Generate Stealth Meta-Address");
+      const chain = options.chain;
+      const useEd25519 = (0, import_sdk.isEd25519Chain)(chain);
+      let metaAddress;
+      if (useEd25519) {
+        if (options.spendingKey || options.viewingKey) {
+          warning("Ed25519 chains do not support custom keys in CLI yet");
+        }
+        metaAddress = (0, import_sdk.generateEd25519StealthMetaAddress)(chain);
+      } else {
+        metaAddress = (0, import_sdk.generateStealthMetaAddress)(chain);
+      }
+      success("Stealth meta-address generated");
+      keyValue("Chain", chain);
+      const spendingPubKey = metaAddress.metaAddress.spendingKey;
+      const viewingPubKey = metaAddress.metaAddress.viewingKey;
+      const spendingPrivKey = metaAddress.spendingPrivateKey;
+      const viewingPrivKey = metaAddress.viewingPrivateKey;
+      keyValue("Spending Public Key", spendingPubKey);
+      keyValue("Viewing Public Key", viewingPubKey);
+      const encoded = (0, import_sdk.encodeStealthMetaAddress)(metaAddress.metaAddress);
+      keyValue("Encoded Address", encoded);
+      console.log();
+      warning("PRIVATE KEYS - Keep these secure!");
+      keyValue("Spending Private Key", spendingPrivKey);
+      keyValue("Viewing Private Key", viewingPrivKey);
+    } catch (err) {
+      console.error("Failed to generate keys:", err);
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/commit.ts
+var import_commander3 = require("commander");
+var import_sdk2 = require("@sip-protocol/sdk");
+function createCommitCommand() {
+  return new import_commander3.Command("commit").description("Create Pedersen commitment").argument("<amount>", "Amount to commit").option("-b, --blinding <factor>", "Blinding factor (hex, optional)").option("--verify", "Verify the commitment after creation").action(async (amountStr, options) => {
+    try {
+      heading("Create Pedersen Commitment");
+      const amount = BigInt(amountStr);
+      info(`Committing amount: ${amount}`);
+      const commitment = options.blinding ? (0, import_sdk2.commit)(amount, options.blinding) : (0, import_sdk2.commit)(amount);
+      success("Commitment created");
+      keyValue("Commitment", commitment.commitment);
+      keyValue("Blinding Factor", commitment.blinding);
+      keyValue("Amount", amount.toString());
+      if (options.verify) {
+        console.log();
+        info("Verifying commitment...");
+        const isValid = (0, import_sdk2.verifyOpening)(commitment.commitment, amount, commitment.blinding);
+        if (isValid) {
+          success("Commitment verified successfully");
+        } else {
+          console.error("Commitment verification failed");
+          process.exit(1);
+        }
+      }
+    } catch (err) {
+      console.error("Failed to create commitment:", err);
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/prove.ts
+var import_commander4 = require("commander");
+var import_sdk3 = require("@sip-protocol/sdk");
+function createProveCommand() {
+  const prove = new import_commander4.Command("prove").description("Generate ZK proof");
+  prove.command("funding").description("Generate funding proof").requiredOption("-b, --balance <amount>", "Current balance").requiredOption("-m, --minimum <amount>", "Minimum required").option("-a, --asset <id>", "Asset identifier", "ETH").option("-u, --user <address>", "User address", "0x0000000000000000000000000000000000000000").action(async (options) => {
+    try {
+      heading("Generate Funding Proof");
+      const blindingFactor = new Uint8Array(32);
+      const ownershipSignature = new Uint8Array(64);
+      const params = {
+        balance: BigInt(options.balance),
+        minimumRequired: BigInt(options.minimum),
+        blindingFactor,
+        assetId: options.asset,
+        userAddress: options.user,
+        ownershipSignature
+      };
+      const spin = spinner("Generating proof...");
+      const provider = new import_sdk3.MockProofProvider({ silent: true });
+      await provider.initialize();
+      const result = await provider.generateFundingProof(params);
+      spin.succeed("Proof generated");
+      success("Funding proof created");
+      keyValue("Proof", result.proof.proof);
+      keyValue("Public Inputs", JSON.stringify(result.publicInputs));
+      keyValue("Type", result.proof.type);
+    } catch (err) {
+      console.error("Failed to generate proof:", err);
+      process.exit(1);
+    }
+  });
+  prove.command("validity").description("Generate validity proof").requiredOption("-i, --intent <hash>", "Intent hash").requiredOption("-s, --sender <address>", "Sender address").action(async (options) => {
+    try {
+      heading("Generate Validity Proof");
+      const senderBlinding = new Uint8Array(32);
+      const senderSecret = new Uint8Array(32);
+      const authorizationSignature = new Uint8Array(64);
+      const nonce = new Uint8Array(32);
+      const now = Math.floor(Date.now() / 1e3);
+      const params = {
+        intentHash: options.intent,
+        senderAddress: options.sender,
+        senderBlinding,
+        senderSecret,
+        authorizationSignature,
+        nonce,
+        timestamp: now,
+        expiry: now + 300
+        // 5 minutes from now
+      };
+      const spin = spinner("Generating proof...");
+      const provider = new import_sdk3.MockProofProvider({ silent: true });
+      await provider.initialize();
+      const result = await provider.generateValidityProof(params);
+      spin.succeed("Proof generated");
+      success("Validity proof created");
+      keyValue("Proof", result.proof.proof);
+      keyValue("Public Inputs", JSON.stringify(result.publicInputs));
+      keyValue("Type", result.proof.type);
+    } catch (err) {
+      console.error("Failed to generate proof:", err);
+      process.exit(1);
+    }
+  });
+  return prove;
+}
+
+// src/commands/verify.ts
+var import_commander5 = require("commander");
+var import_sdk4 = require("@sip-protocol/sdk");
+function createVerifyCommand() {
+  return new import_commander5.Command("verify").description("Verify ZK proof").argument("<proof>", "Proof to verify (hex string)").option("-t, --type <type>", "Proof type (funding|validity|fulfillment)", "funding").option("-p, --public-inputs <json>", "Public inputs (JSON array)").action(async (proofHex, options) => {
+    try {
+      heading("Verify ZK Proof");
+      info(`Proof type: ${options.type}`);
+      info(`Proof: ${proofHex.slice(0, 20)}...`);
+      const publicInputs = options.publicInputs ? JSON.parse(options.publicInputs) : [];
+      const proofHexStr = proofHex.startsWith("0x") ? proofHex : `0x${proofHex}`;
+      const zkProof = {
+        type: options.type,
+        proof: proofHexStr,
+        publicInputs
+      };
+      const spin = spinner("Verifying proof...");
+      const provider = new import_sdk4.MockProofProvider({ silent: true });
+      await provider.initialize();
+      const isValid = await provider.verifyProof(zkProof);
+      spin.stop();
+      if (isValid) {
+        success(`Proof is valid (type: ${options.type})`);
+      } else {
+        error("Proof is invalid");
+        process.exit(1);
+      }
+    } catch (err) {
+      console.error("Failed to verify proof:", err);
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/quote.ts
+var import_commander6 = require("commander");
+var import_sdk5 = require("@sip-protocol/sdk");
+function createQuoteCommand() {
+  return new import_commander6.Command("quote").description("Get swap quote").argument("<from-chain>", "Source chain (e.g., ethereum, solana)").argument("<to-chain>", "Destination chain").argument("<amount>", "Amount to swap").option("-t, --token <symbol>", "Token symbol (default: native token)").option("-p, --privacy <level>", "Privacy level (transparent|shielded|compliant)").action(async (fromChain, toChain, amountStr, options) => {
+    try {
+      heading("Get Swap Quote");
+      const config = getConfig();
+      const amount = BigInt(amountStr);
+      const privacy = options.privacy || config.defaultPrivacy;
+      const sip = (0, import_sdk5.createSIP)(config.network);
+      const spin = spinner("Fetching quotes...");
+      const inputAsset = import_sdk5.NATIVE_TOKENS[fromChain] || {
+        chain: fromChain,
+        symbol: options.token || "native",
+        address: null,
+        decimals: 18
+      };
+      const outputAsset = import_sdk5.NATIVE_TOKENS[toChain] || {
+        chain: toChain,
+        symbol: options.token || "native",
+        address: null,
+        decimals: 18
+      };
+      const intent = await sip.createIntent({
+        input: {
+          asset: inputAsset,
+          amount
+        },
+        output: {
+          asset: outputAsset,
+          minAmount: 0n,
+          // Accept any amount for quote discovery
+          maxSlippage: 0.05
+          // 5% slippage tolerance
+        },
+        privacy
+      });
+      const quotes = await sip.getQuotes(intent);
+      spin.succeed(`Found ${quotes.length} quote(s)`);
+      if (quotes.length === 0) {
+        console.log("\nNo quotes available");
+        return;
+      }
+      console.log();
+      const headers = ["Solver", "Output Amount", "Fee", "Time (s)"];
+      const rows = quotes.map((q) => [
+        q.solverId,
+        formatAmount(q.outputAmount),
+        formatAmount(q.fee),
+        q.estimatedTime.toString()
+      ]);
+      table(headers, rows);
+      const best = quotes[0];
+      console.log();
+      success("Best quote:");
+      keyValue("Solver", best.solverId);
+      keyValue("Output Amount", formatAmount(best.outputAmount));
+      keyValue("Estimated Time", `${best.estimatedTime}s`);
+    } catch (err) {
+      console.error("Failed to get quote:", err);
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/swap.ts
+var import_commander7 = require("commander");
+var import_sdk6 = require("@sip-protocol/sdk");
+function createSwapCommand() {
+  return new import_commander7.Command("swap").description("Execute swap").argument("<from-chain>", "Source chain (e.g., ethereum, solana)").argument("<to-chain>", "Destination chain").argument("<amount>", "Amount to swap").option("-t, --token <symbol>", "Token symbol (default: native token)").option("-p, --privacy <level>", "Privacy level (transparent|shielded|compliant)").option("-r, --recipient <address>", "Recipient address (optional)").option("--solver <id>", "Specific solver to use").action(async (fromChain, toChain, amountStr, options) => {
+    try {
+      heading("Execute Swap");
+      const config = getConfig();
+      const amount = BigInt(amountStr);
+      const privacy = options.privacy || config.defaultPrivacy;
+      const sip = (0, import_sdk6.createSIP)(config.network);
+      const inputAsset = import_sdk6.NATIVE_TOKENS[fromChain] || {
+        chain: fromChain,
+        symbol: options.token || "native",
+        address: null,
+        decimals: 18
+      };
+      const outputAsset = import_sdk6.NATIVE_TOKENS[toChain] || {
+        chain: toChain,
+        symbol: options.token || "native",
+        address: null,
+        decimals: 18
+      };
+      info("Creating shielded intent...");
+      const intent = await sip.createIntent({
+        input: {
+          asset: inputAsset,
+          amount
+        },
+        output: {
+          asset: outputAsset,
+          minAmount: 0n,
+          // Accept any amount
+          maxSlippage: 0.05
+          // 5% slippage tolerance
+        },
+        privacy,
+        recipientMetaAddress: options.recipient
+      });
+      success("Intent created");
+      keyValue("Intent ID", formatHash(intent.intentId));
+      const spin = spinner("Fetching quotes...");
+      const quotes = await sip.getQuotes(intent);
+      spin.succeed(`Found ${quotes.length} quote(s)`);
+      if (quotes.length === 0) {
+        console.error("\nNo quotes available");
+        process.exit(1);
+      }
+      const selectedQuote = options.solver ? quotes.find((q) => q.solverId === options.solver) : quotes[0];
+      if (!selectedQuote) {
+        console.error(`
+Solver not found: ${options.solver}`);
+        process.exit(1);
+      }
+      info(`Using solver: ${selectedQuote.solverId}`);
+      keyValue("Output Amount", formatAmount(selectedQuote.outputAmount));
+      const executeSpin = spinner("Executing swap...");
+      const result = await sip.execute(intent, selectedQuote);
+      executeSpin.succeed("Swap executed");
+      success("Swap completed successfully");
+      if (result.txHash) {
+        keyValue("Transaction Hash", formatHash(result.txHash));
+      }
+      if (result.outputAmount) {
+        keyValue("Output Amount", formatAmount(result.outputAmount));
+      }
+      keyValue("Status", result.status);
+    } catch (err) {
+      console.error("Failed to execute swap:", err);
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/scan.ts
+var import_commander8 = require("commander");
+var import_sdk7 = require("@sip-protocol/sdk");
+function createScanCommand() {
+  return new import_commander8.Command("scan").description("Scan for stealth payments").requiredOption("-c, --chain <chain>", "Chain to scan (ethereum, solana, near)").requiredOption("-s, --spending-key <key>", "Your spending private key (hex)").requiredOption("-v, --viewing-key <key>", "Your viewing private key (hex)").option("-a, --addresses <addresses...>", "Specific addresses to check").action(async (options) => {
+    try {
+      heading("Scan for Stealth Payments");
+      const chain = options.chain;
+      const useEd25519 = (0, import_sdk7.isEd25519Chain)(chain);
+      info(`Scanning ${chain} for stealth payments...`);
+      info(`Using ${useEd25519 ? "ed25519" : "secp256k1"} curve`);
+      if (!options.addresses || options.addresses.length === 0) {
+        warning("No addresses provided. Specify addresses with -a flag.");
+        info("Example: sip scan -c ethereum -s 0x... -v 0x... -a 0xabc... 0xdef...");
+        return;
+      }
+      const results = [];
+      for (const address of options.addresses) {
+        try {
+          let result;
+          if (useEd25519) {
+            result = (0, import_sdk7.checkEd25519StealthAddress)(
+              address,
+              options.spendingKey,
+              options.viewingKey
+            );
+          } else {
+            result = (0, import_sdk7.checkStealthAddress)(
+              address,
+              options.spendingKey,
+              options.viewingKey
+            );
+          }
+          results.push({
+            address,
+            isMine: result.isMine,
+            privateKey: result.isMine ? result.stealthPrivateKey : void 0
+          });
+        } catch (err) {
+          results.push({
+            address,
+            isMine: false
+          });
+        }
+      }
+      console.log();
+      const foundCount = results.filter((r) => r.isMine).length;
+      success(`Scanned ${results.length} address(es), found ${foundCount} stealth payment(s)`);
+      if (foundCount > 0) {
+        console.log();
+        const headers = ["Address", "Match", "Private Key"];
+        const rows = results.filter((r) => r.isMine).map((r) => [
+          r.address.slice(0, 10) + "...",
+          "Yes",
+          r.privateKey ? r.privateKey.slice(0, 10) + "..." : "N/A"
+        ]);
+        table(headers, rows);
+        console.log();
+        warning("Store the private keys securely to access these funds");
+      } else {
+        info("No stealth payments found");
+      }
+    } catch (err) {
+      console.error("Failed to scan:", err);
+      process.exit(1);
+    }
+  });
+}
+
+// src/index.ts
+var program = new import_commander9.Command();
+program.name("sip").description("Shielded Intents Protocol (SIP) - Privacy layer for cross-chain transactions").version("0.1.0");
+program.addCommand(createInitCommand());
+program.addCommand(createKeygenCommand());
+program.addCommand(createCommitCommand());
+program.addCommand(createProveCommand());
+program.addCommand(createVerifyCommand());
+program.addCommand(createQuoteCommand());
+program.addCommand(createSwapCommand());
+program.addCommand(createScanCommand());
+program.parse();

package/dist/index.mjs

@@ -0,0 +1,520 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command as Command9 } from "commander";
+
+// src/commands/init.ts
+import { Command } from "commander";
+import { PrivacyLevel } from "@sip-protocol/types";
+
+// src/utils/config.ts
+import Conf from "conf";
+var schema = {
+  network: {
+    type: "string",
+    default: "testnet"
+  },
+  defaultPrivacy: {
+    type: "string",
+    default: "transparent"
+  }
+};
+var store = new Conf({
+  projectName: "sip-protocol",
+  schema
+});
+function getConfig() {
+  return {
+    network: store.get("network"),
+    defaultPrivacy: store.get("defaultPrivacy"),
+    defaultChain: store.get("defaultChain"),
+    rpcEndpoints: store.get("rpcEndpoints")
+  };
+}
+function setConfig(key, value) {
+  store.set(key, value);
+}
+function resetConfig() {
+  store.clear();
+}
+function getConfigPath() {
+  return store.path;
+}
+
+// src/utils/output.ts
+import chalk from "chalk";
+import ora from "ora";
+function success(message) {
+  console.log(chalk.green("\u2713"), message);
+}
+function error(message) {
+  console.error(chalk.red("\u2717"), message);
+}
+function warning(message) {
+  console.warn(chalk.yellow("\u26A0"), message);
+}
+function info(message) {
+  console.log(chalk.blue("\u2139"), message);
+}
+function heading(message) {
+  console.log(chalk.bold.cyan(`
+${message}
+`));
+}
+function keyValue(key, value) {
+  console.log(chalk.gray(`  ${key}:`), chalk.white(String(value)));
+}
+function spinner(text) {
+  return ora(text).start();
+}
+function table(headers, rows) {
+  const colWidths = headers.map(
+    (h, i) => Math.max(h.length, ...rows.map((r) => String(r[i] || "").length))
+  );
+  console.log(
+    headers.map((h, i) => chalk.bold(h.padEnd(colWidths[i]))).join("  ")
+  );
+  console.log(colWidths.map((w) => "\u2500".repeat(w)).join("  "));
+  rows.forEach((row) => {
+    console.log(
+      row.map((cell, i) => String(cell).padEnd(colWidths[i])).join("  ")
+    );
+  });
+}
+function formatAmount(amount, decimals = 18) {
+  const divisor = 10n ** BigInt(decimals);
+  const integer = amount / divisor;
+  const fraction = amount % divisor;
+  const fractionStr = fraction.toString().padStart(decimals, "0").slice(0, 6);
+  return `${integer}.${fractionStr}`;
+}
+function formatHash(hash, length = 8) {
+  if (hash.length <= length * 2) return hash;
+  return `${hash.slice(0, length)}...${hash.slice(-length)}`;
+}
+
+// src/commands/init.ts
+function createInitCommand() {
+  return new Command("init").description("Initialize SIP configuration").option("-n, --network <network>", "Network (mainnet|testnet)", "testnet").option("-p, --privacy <level>", "Default privacy level", "transparent").option("--reset", "Reset configuration to defaults").action(async (options) => {
+    try {
+      heading("Initialize SIP Protocol");
+      if (options.reset) {
+        resetConfig();
+        success("Configuration reset to defaults");
+      }
+      const privacy = options.privacy;
+      if (!Object.values(PrivacyLevel).includes(privacy)) {
+        throw new Error(`Invalid privacy level: ${privacy}`);
+      }
+      setConfig("network", options.network);
+      setConfig("defaultPrivacy", privacy);
+      success("SIP initialized successfully");
+      info(`Network: ${options.network}`);
+      info(`Default Privacy: ${privacy}`);
+      info(`Config file: ${getConfigPath()}`);
+    } catch (err) {
+      console.error("Failed to initialize:", err);
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/keygen.ts
+import { Command as Command2 } from "commander";
+import {
+  generateStealthMetaAddress,
+  generateEd25519StealthMetaAddress,
+  isEd25519Chain,
+  encodeStealthMetaAddress
+} from "@sip-protocol/sdk";
+function createKeygenCommand() {
+  return new Command2("keygen").description("Generate stealth meta-address").option("-c, --chain <chain>", "Target chain (ethereum, solana, near)", "ethereum").option("--spending-key <key>", "Spending private key (hex)").option("--viewing-key <key>", "Viewing private key (hex)").action(async (options) => {
+    try {
+      heading("Generate Stealth Meta-Address");
+      const chain = options.chain;
+      const useEd25519 = isEd25519Chain(chain);
+      let metaAddress;
+      if (useEd25519) {
+        if (options.spendingKey || options.viewingKey) {
+          warning("Ed25519 chains do not support custom keys in CLI yet");
+        }
+        metaAddress = generateEd25519StealthMetaAddress(chain);
+      } else {
+        metaAddress = generateStealthMetaAddress(chain);
+      }
+      success("Stealth meta-address generated");
+      keyValue("Chain", chain);
+      const spendingPubKey = metaAddress.metaAddress.spendingKey;
+      const viewingPubKey = metaAddress.metaAddress.viewingKey;
+      const spendingPrivKey = metaAddress.spendingPrivateKey;
+      const viewingPrivKey = metaAddress.viewingPrivateKey;
+      keyValue("Spending Public Key", spendingPubKey);
+      keyValue("Viewing Public Key", viewingPubKey);
+      const encoded = encodeStealthMetaAddress(metaAddress.metaAddress);
+      keyValue("Encoded Address", encoded);
+      console.log();
+      warning("PRIVATE KEYS - Keep these secure!");
+      keyValue("Spending Private Key", spendingPrivKey);
+      keyValue("Viewing Private Key", viewingPrivKey);
+    } catch (err) {
+      console.error("Failed to generate keys:", err);
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/commit.ts
+import { Command as Command3 } from "commander";
+import { commit, verifyOpening } from "@sip-protocol/sdk";
+function createCommitCommand() {
+  return new Command3("commit").description("Create Pedersen commitment").argument("<amount>", "Amount to commit").option("-b, --blinding <factor>", "Blinding factor (hex, optional)").option("--verify", "Verify the commitment after creation").action(async (amountStr, options) => {
+    try {
+      heading("Create Pedersen Commitment");
+      const amount = BigInt(amountStr);
+      info(`Committing amount: ${amount}`);
+      const commitment = options.blinding ? commit(amount, options.blinding) : commit(amount);
+      success("Commitment created");
+      keyValue("Commitment", commitment.commitment);
+      keyValue("Blinding Factor", commitment.blinding);
+      keyValue("Amount", amount.toString());
+      if (options.verify) {
+        console.log();
+        info("Verifying commitment...");
+        const isValid = verifyOpening(commitment.commitment, amount, commitment.blinding);
+        if (isValid) {
+          success("Commitment verified successfully");
+        } else {
+          console.error("Commitment verification failed");
+          process.exit(1);
+        }
+      }
+    } catch (err) {
+      console.error("Failed to create commitment:", err);
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/prove.ts
+import { Command as Command4 } from "commander";
+import { MockProofProvider } from "@sip-protocol/sdk";
+function createProveCommand() {
+  const prove = new Command4("prove").description("Generate ZK proof");
+  prove.command("funding").description("Generate funding proof").requiredOption("-b, --balance <amount>", "Current balance").requiredOption("-m, --minimum <amount>", "Minimum required").option("-a, --asset <id>", "Asset identifier", "ETH").option("-u, --user <address>", "User address", "0x0000000000000000000000000000000000000000").action(async (options) => {
+    try {
+      heading("Generate Funding Proof");
+      const blindingFactor = new Uint8Array(32);
+      const ownershipSignature = new Uint8Array(64);
+      const params = {
+        balance: BigInt(options.balance),
+        minimumRequired: BigInt(options.minimum),
+        blindingFactor,
+        assetId: options.asset,
+        userAddress: options.user,
+        ownershipSignature
+      };
+      const spin = spinner("Generating proof...");
+      const provider = new MockProofProvider({ silent: true });
+      await provider.initialize();
+      const result = await provider.generateFundingProof(params);
+      spin.succeed("Proof generated");
+      success("Funding proof created");
+      keyValue("Proof", result.proof.proof);
+      keyValue("Public Inputs", JSON.stringify(result.publicInputs));
+      keyValue("Type", result.proof.type);
+    } catch (err) {
+      console.error("Failed to generate proof:", err);
+      process.exit(1);
+    }
+  });
+  prove.command("validity").description("Generate validity proof").requiredOption("-i, --intent <hash>", "Intent hash").requiredOption("-s, --sender <address>", "Sender address").action(async (options) => {
+    try {
+      heading("Generate Validity Proof");
+      const senderBlinding = new Uint8Array(32);
+      const senderSecret = new Uint8Array(32);
+      const authorizationSignature = new Uint8Array(64);
+      const nonce = new Uint8Array(32);
+      const now = Math.floor(Date.now() / 1e3);
+      const params = {
+        intentHash: options.intent,
+        senderAddress: options.sender,
+        senderBlinding,
+        senderSecret,
+        authorizationSignature,
+        nonce,
+        timestamp: now,
+        expiry: now + 300
+        // 5 minutes from now
+      };
+      const spin = spinner("Generating proof...");
+      const provider = new MockProofProvider({ silent: true });
+      await provider.initialize();
+      const result = await provider.generateValidityProof(params);
+      spin.succeed("Proof generated");
+      success("Validity proof created");
+      keyValue("Proof", result.proof.proof);
+      keyValue("Public Inputs", JSON.stringify(result.publicInputs));
+      keyValue("Type", result.proof.type);
+    } catch (err) {
+      console.error("Failed to generate proof:", err);
+      process.exit(1);
+    }
+  });
+  return prove;
+}
+
+// src/commands/verify.ts
+import { Command as Command5 } from "commander";
+import { MockProofProvider as MockProofProvider2 } from "@sip-protocol/sdk";
+function createVerifyCommand() {
+  return new Command5("verify").description("Verify ZK proof").argument("<proof>", "Proof to verify (hex string)").option("-t, --type <type>", "Proof type (funding|validity|fulfillment)", "funding").option("-p, --public-inputs <json>", "Public inputs (JSON array)").action(async (proofHex, options) => {
+    try {
+      heading("Verify ZK Proof");
+      info(`Proof type: ${options.type}`);
+      info(`Proof: ${proofHex.slice(0, 20)}...`);
+      const publicInputs = options.publicInputs ? JSON.parse(options.publicInputs) : [];
+      const proofHexStr = proofHex.startsWith("0x") ? proofHex : `0x${proofHex}`;
+      const zkProof = {
+        type: options.type,
+        proof: proofHexStr,
+        publicInputs
+      };
+      const spin = spinner("Verifying proof...");
+      const provider = new MockProofProvider2({ silent: true });
+      await provider.initialize();
+      const isValid = await provider.verifyProof(zkProof);
+      spin.stop();
+      if (isValid) {
+        success(`Proof is valid (type: ${options.type})`);
+      } else {
+        error("Proof is invalid");
+        process.exit(1);
+      }
+    } catch (err) {
+      console.error("Failed to verify proof:", err);
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/quote.ts
+import { Command as Command6 } from "commander";
+import { createSIP, NATIVE_TOKENS } from "@sip-protocol/sdk";
+function createQuoteCommand() {
+  return new Command6("quote").description("Get swap quote").argument("<from-chain>", "Source chain (e.g., ethereum, solana)").argument("<to-chain>", "Destination chain").argument("<amount>", "Amount to swap").option("-t, --token <symbol>", "Token symbol (default: native token)").option("-p, --privacy <level>", "Privacy level (transparent|shielded|compliant)").action(async (fromChain, toChain, amountStr, options) => {
+    try {
+      heading("Get Swap Quote");
+      const config = getConfig();
+      const amount = BigInt(amountStr);
+      const privacy = options.privacy || config.defaultPrivacy;
+      const sip = createSIP(config.network);
+      const spin = spinner("Fetching quotes...");
+      const inputAsset = NATIVE_TOKENS[fromChain] || {
+        chain: fromChain,
+        symbol: options.token || "native",
+        address: null,
+        decimals: 18
+      };
+      const outputAsset = NATIVE_TOKENS[toChain] || {
+        chain: toChain,
+        symbol: options.token || "native",
+        address: null,
+        decimals: 18
+      };
+      const intent = await sip.createIntent({
+        input: {
+          asset: inputAsset,
+          amount
+        },
+        output: {
+          asset: outputAsset,
+          minAmount: 0n,
+          // Accept any amount for quote discovery
+          maxSlippage: 0.05
+          // 5% slippage tolerance
+        },
+        privacy
+      });
+      const quotes = await sip.getQuotes(intent);
+      spin.succeed(`Found ${quotes.length} quote(s)`);
+      if (quotes.length === 0) {
+        console.log("\nNo quotes available");
+        return;
+      }
+      console.log();
+      const headers = ["Solver", "Output Amount", "Fee", "Time (s)"];
+      const rows = quotes.map((q) => [
+        q.solverId,
+        formatAmount(q.outputAmount),
+        formatAmount(q.fee),
+        q.estimatedTime.toString()
+      ]);
+      table(headers, rows);
+      const best = quotes[0];
+      console.log();
+      success("Best quote:");
+      keyValue("Solver", best.solverId);
+      keyValue("Output Amount", formatAmount(best.outputAmount));
+      keyValue("Estimated Time", `${best.estimatedTime}s`);
+    } catch (err) {
+      console.error("Failed to get quote:", err);
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/swap.ts
+import { Command as Command7 } from "commander";
+import { createSIP as createSIP2, NATIVE_TOKENS as NATIVE_TOKENS2 } from "@sip-protocol/sdk";
+function createSwapCommand() {
+  return new Command7("swap").description("Execute swap").argument("<from-chain>", "Source chain (e.g., ethereum, solana)").argument("<to-chain>", "Destination chain").argument("<amount>", "Amount to swap").option("-t, --token <symbol>", "Token symbol (default: native token)").option("-p, --privacy <level>", "Privacy level (transparent|shielded|compliant)").option("-r, --recipient <address>", "Recipient address (optional)").option("--solver <id>", "Specific solver to use").action(async (fromChain, toChain, amountStr, options) => {
+    try {
+      heading("Execute Swap");
+      const config = getConfig();
+      const amount = BigInt(amountStr);
+      const privacy = options.privacy || config.defaultPrivacy;
+      const sip = createSIP2(config.network);
+      const inputAsset = NATIVE_TOKENS2[fromChain] || {
+        chain: fromChain,
+        symbol: options.token || "native",
+        address: null,
+        decimals: 18
+      };
+      const outputAsset = NATIVE_TOKENS2[toChain] || {
+        chain: toChain,
+        symbol: options.token || "native",
+        address: null,
+        decimals: 18
+      };
+      info("Creating shielded intent...");
+      const intent = await sip.createIntent({
+        input: {
+          asset: inputAsset,
+          amount
+        },
+        output: {
+          asset: outputAsset,
+          minAmount: 0n,
+          // Accept any amount
+          maxSlippage: 0.05
+          // 5% slippage tolerance
+        },
+        privacy,
+        recipientMetaAddress: options.recipient
+      });
+      success("Intent created");
+      keyValue("Intent ID", formatHash(intent.intentId));
+      const spin = spinner("Fetching quotes...");
+      const quotes = await sip.getQuotes(intent);
+      spin.succeed(`Found ${quotes.length} quote(s)`);
+      if (quotes.length === 0) {
+        console.error("\nNo quotes available");
+        process.exit(1);
+      }
+      const selectedQuote = options.solver ? quotes.find((q) => q.solverId === options.solver) : quotes[0];
+      if (!selectedQuote) {
+        console.error(`
+Solver not found: ${options.solver}`);
+        process.exit(1);
+      }
+      info(`Using solver: ${selectedQuote.solverId}`);
+      keyValue("Output Amount", formatAmount(selectedQuote.outputAmount));
+      const executeSpin = spinner("Executing swap...");
+      const result = await sip.execute(intent, selectedQuote);
+      executeSpin.succeed("Swap executed");
+      success("Swap completed successfully");
+      if (result.txHash) {
+        keyValue("Transaction Hash", formatHash(result.txHash));
+      }
+      if (result.outputAmount) {
+        keyValue("Output Amount", formatAmount(result.outputAmount));
+      }
+      keyValue("Status", result.status);
+    } catch (err) {
+      console.error("Failed to execute swap:", err);
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/scan.ts
+import { Command as Command8 } from "commander";
+import { checkStealthAddress, checkEd25519StealthAddress, isEd25519Chain as isEd25519Chain2 } from "@sip-protocol/sdk";
+function createScanCommand() {
+  return new Command8("scan").description("Scan for stealth payments").requiredOption("-c, --chain <chain>", "Chain to scan (ethereum, solana, near)").requiredOption("-s, --spending-key <key>", "Your spending private key (hex)").requiredOption("-v, --viewing-key <key>", "Your viewing private key (hex)").option("-a, --addresses <addresses...>", "Specific addresses to check").action(async (options) => {
+    try {
+      heading("Scan for Stealth Payments");
+      const chain = options.chain;
+      const useEd25519 = isEd25519Chain2(chain);
+      info(`Scanning ${chain} for stealth payments...`);
+      info(`Using ${useEd25519 ? "ed25519" : "secp256k1"} curve`);
+      if (!options.addresses || options.addresses.length === 0) {
+        warning("No addresses provided. Specify addresses with -a flag.");
+        info("Example: sip scan -c ethereum -s 0x... -v 0x... -a 0xabc... 0xdef...");
+        return;
+      }
+      const results = [];
+      for (const address of options.addresses) {
+        try {
+          let result;
+          if (useEd25519) {
+            result = checkEd25519StealthAddress(
+              address,
+              options.spendingKey,
+              options.viewingKey
+            );
+          } else {
+            result = checkStealthAddress(
+              address,
+              options.spendingKey,
+              options.viewingKey
+            );
+          }
+          results.push({
+            address,
+            isMine: result.isMine,
+            privateKey: result.isMine ? result.stealthPrivateKey : void 0
+          });
+        } catch (err) {
+          results.push({
+            address,
+            isMine: false
+          });
+        }
+      }
+      console.log();
+      const foundCount = results.filter((r) => r.isMine).length;
+      success(`Scanned ${results.length} address(es), found ${foundCount} stealth payment(s)`);
+      if (foundCount > 0) {
+        console.log();
+        const headers = ["Address", "Match", "Private Key"];
+        const rows = results.filter((r) => r.isMine).map((r) => [
+          r.address.slice(0, 10) + "...",
+          "Yes",
+          r.privateKey ? r.privateKey.slice(0, 10) + "..." : "N/A"
+        ]);
+        table(headers, rows);
+        console.log();
+        warning("Store the private keys securely to access these funds");
+      } else {
+        info("No stealth payments found");
+      }
+    } catch (err) {
+      console.error("Failed to scan:", err);
+      process.exit(1);
+    }
+  });
+}
+
+// src/index.ts
+var program = new Command9();
+program.name("sip").description("Shielded Intents Protocol (SIP) - Privacy layer for cross-chain transactions").version("0.1.0");
+program.addCommand(createInitCommand());
+program.addCommand(createKeygenCommand());
+program.addCommand(createCommitCommand());
+program.addCommand(createProveCommand());
+program.addCommand(createVerifyCommand());
+program.addCommand(createQuoteCommand());
+program.addCommand(createSwapCommand());
+program.addCommand(createScanCommand());
+program.parse();

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "@sip-protocol/cli",
+  "version": "0.1.0",
+  "description": "Command-line tool for Shielded Intents Protocol (SIP) operations",
+  "author": "SIP Protocol <hello@sip-protocol.org>",
+  "homepage": "https://sip-protocol.org",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/sip-protocol/sip-protocol.git",
+    "directory": "packages/cli"
+  },
+  "bugs": {
+    "url": "https://github.com/sip-protocol/sip-protocol/issues"
+  },
+  "bin": {
+    "sip": "./bin/sip.js"
+  },
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "bin",
+    "dist"
+  ],
+  "dependencies": {
+    "@sip-protocol/sdk": "^0.6.0",
+    "@sip-protocol/types": "^0.2.0",
+    "commander": "^12.0.0",
+    "chalk": "^4.1.2",
+    "ora": "^5.4.1",
+    "conf": "^10.2.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.10.0",
+    "tsup": "^8.0.0",
+    "typescript": "^5.3.0",
+    "vitest": "^1.1.0"
+  },
+  "keywords": [
+    "sip",
+    "cli",
+    "privacy",
+    "intents",
+    "cross-chain",
+    "stealth-addresses",
+    "zcash"
+  ],
+  "license": "MIT",
+  "scripts": {
+    "build": "tsup src/index.ts --format cjs,esm --dts && chmod +x bin/sip.js",
+    "dev": "tsup src/index.ts --format cjs,esm --dts --watch",
+    "lint": "eslint --ext .ts src/",
+    "typecheck": "tsc --noEmit",
+    "clean": "rm -rf dist",
+    "test": "vitest --passWithNoTests"
+  }
+}