hufi-cli 0.6.1 → 0.8.1

package/README.md

@@ -56,6 +56,7 @@ hufi auth status
 | `campaign status` | Check join status |
 | `campaign progress` | Check your progress |
 | `campaign leaderboard` | View campaign leaderboard |
+| `campaign create` | Create a new campaign (launch escrow on-chain) |
 
 ```bash
 hufi campaign list                                          # list active campaigns
@@ -67,6 +68,33 @@ hufi campaign progress --address 0x...                      # your progress
 hufi campaign leaderboard --address 0x...                   # leaderboard
 ```
 
+#### Campaign Create
+
+Requires staked HMT, gas, and fund tokens (USDT/USDC). Creates an escrow contract on-chain.
+
+```bash
+# Market Making
+hufi campaign create \
+  --type market_making --exchange mexc --symbol HMT/USDT \
+  --start-date 2026-04-01 --end-date 2026-05-01 \
+  --fund-token USDT --fund-amount 10000 \
+  --daily-volume-target 50000
+
+# Holding
+hufi campaign create \
+  --type holding --exchange mexc --symbol HMT \
+  --start-date 2026-04-01 --end-date 2026-05-01 \
+  --fund-token USDT --fund-amount 5000 \
+  --daily-balance-target 1000
+
+# Threshold
+hufi campaign create \
+  --type threshold --exchange mexc --symbol HMT \
+  --start-date 2026-04-01 --end-date 2026-05-01 \
+  --fund-token USDT --fund-amount 5000 \
+  --minimum-balance-target 500
+```
+
 Running `campaign status/join/progress/leaderboard` without `-a` shows help.
 
 ### exchange
@@ -75,10 +103,14 @@ Running `campaign status/join/progress/leaderboard` without `-a` shows help.
 |---------|-------------|
 | `exchange register` | Register a read-only exchange API key |
 | `exchange list` | List registered API keys |
+| `exchange delete` | Delete API keys for an exchange |
+| `exchange revalidate` | Revalidate an exchange API key |
 
 ```bash
 hufi exchange register --name mexc --api-key <key> --secret-key <secret>
 hufi exchange list
+hufi exchange revalidate --name mexc
+hufi exchange delete --name mexc
 ```
 
 ### staking
@@ -102,6 +134,15 @@ hufi staking withdraw                                  # withdraw unlocked token
 
 Supports Polygon (chain 137) and Ethereum (chain 1). Staking contract: `0x01D1...07F1D` on Polygon.
 
+### dashboard
+
+Portfolio overview — staking, active campaigns, and progress in one view.
+
+```bash
+hufi dashboard              # full overview
+hufi dashboard --json       # machine output
+```
+
 ## Global Options
 
 | Option | Description |

package/dist/cli.js

@@ -22958,6 +22958,18 @@ async function listExchangeApiKeys(baseUrl, accessToken) {
     headers: authHeaders(accessToken)
   });
 }
+async function deleteExchangeApiKey(baseUrl, accessToken, exchangeName) {
+  await requestJson(`${baseUrl}/exchange-api-keys/${exchangeName}`, {
+    method: "DELETE",
+    headers: authHeaders(accessToken)
+  });
+}
+async function revalidateExchangeApiKey(baseUrl, accessToken, exchangeName) {
+  return await requestJson(`${baseUrl}/exchange-api-keys/${exchangeName}/revalidate`, {
+    method: "POST",
+    headers: authHeaders(accessToken)
+  });
+}
 
 // src/commands/exchange.ts
 function requireAuth() {
@@ -23013,6 +23025,40 @@ function createExchangeCommand() {
       process.exitCode = 1;
     }
   });
+  exchange.command("delete").description("Delete API keys for an exchange").requiredOption("-n, --name <name>", "Exchange name (e.g. mexc, bybit)").option("--json", "Output as JSON").action(async (opts) => {
+    const { baseUrl, accessToken } = requireAuth();
+    try {
+      await deleteExchangeApiKey(baseUrl, accessToken, opts.name);
+      if (opts.json) {
+        printJson({ deleted: true, exchange_name: opts.name });
+      } else {
+        printText(`Deleted API keys for ${opts.name}.`);
+      }
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      printText(`Failed to delete exchange API keys: ${message}`);
+      process.exitCode = 1;
+    }
+  });
+  exchange.command("revalidate").description("Revalidate exchange API key").requiredOption("-n, --name <name>", "Exchange name (e.g. mexc, bybit)").option("--json", "Output as JSON").action(async (opts) => {
+    const { baseUrl, accessToken } = requireAuth();
+    try {
+      const result = await revalidateExchangeApiKey(baseUrl, accessToken, opts.name);
+      if (opts.json) {
+        printJson(result);
+      } else {
+        const status = result.is_valid ? "valid" : "invalid";
+        printText(`${opts.name}: ${status}`);
+        if (result.missing_permissions.length > 0) {
+          printText(`Missing permissions: ${result.missing_permissions.join(", ")}`);
+        }
+      }
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      printText(`Failed to revalidate exchange API key: ${message}`);
+      process.exitCode = 1;
+    }
+  });
   return exchange;
 }
 
@@ -24491,6 +24537,159 @@ async function getLeaderboard(baseUrl, chainId, campaignAddress, rankBy, limit =
   return await requestJson(`${baseUrl}/campaigns/${chainId}-${campaignAddress}/leaderboard?rankBy=${rankBy}&limit=${limit}`);
 }
 
+// src/services/campaign-create.ts
+import { createHash as createHash2 } from "node:crypto";
+
+// src/lib/contracts.ts
+var HUMAN_PROTOCOL_CONTRACTS = {
+  137: {
+    hmt: "0xc748B2A084F8eFc47E086ccdDD9b7e67aEb571BF",
+    staking: "0x01D115E9E8bF0C58318793624CC662a030D07F1D",
+    escrowFactory: "0x8D50dA7abe354a628a63ADfE23C19a2944612b83"
+  },
+  1: {
+    hmt: "0xd1ba9BAC957322D6e8c07a160a3A8dA11A0d2867",
+    staking: "0x86Af9f6Cd34B69Db1B202223C6d6D109f2491569",
+    escrowFactory: "0xE24e5C08E28331D24758b69A5E9f383D2bDD1c98"
+  }
+};
+var RPC_URLS = {
+  137: [
+    "https://polygon.drpc.org",
+    "https://rpc.ankr.com/polygon",
+    "https://polygon-mainnet.public.blastapi.io"
+  ],
+  1: [
+    "https://eth.drpc.org",
+    "https://rpc.ankr.com/eth",
+    "https://ethereum-rpc.publicnode.com"
+  ]
+};
+var ORACLES = {
+  exchangeOracle: "0x5b74d007ea08217bcde942a2132df43d568a6dca",
+  recordingOracle: "0x3a2292c684e289fe5f07737b598fe0027ead5a0e",
+  reputationOracle: "0x1519964f5cd2d9ef162b2b1b66f33669cca065c8"
+};
+var FUND_TOKENS = {
+  137: {
+    USDT: "0xc2132D05D31c914a87C6611C10748AEb04B58e8F",
+    USDC: "0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359"
+  },
+  1: {
+    USDT: "0xdAC17F958D2ee523a2206206994597C13D831ec7",
+    USDC: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48"
+  }
+};
+var ESCROW_FACTORY_ABI = [
+  "function createFundAndSetupEscrow(address token, uint256 amount, string jobRequesterId, address reputationOracle, address recordingOracle, address exchangeOracle, string manifest, string manifestHash) returns (address)",
+  "event LaunchedV2(address indexed escrow, address indexed launcher, string jobRequesterId)"
+];
+var ERC20_ABI = [
+  "function balanceOf(address) external view returns (uint256)",
+  "function allowance(address owner, address spender) external view returns (uint256)",
+  "function approve(address spender, uint256 amount) external returns (bool)",
+  "function decimals() external view returns (uint8)"
+];
+function getContracts(chainId) {
+  const c = HUMAN_PROTOCOL_CONTRACTS[chainId];
+  if (!c) {
+    throw new Error(`Unsupported chain ID: ${chainId}. Supported: ${Object.keys(HUMAN_PROTOCOL_CONTRACTS).join(", ")}`);
+  }
+  return c;
+}
+function getRpc(chainId) {
+  const rpcs = RPC_URLS[chainId];
+  if (!rpcs) {
+    throw new Error(`No RPC URLs for chain ${chainId}`);
+  }
+  return rpcs[0];
+}
+function getFundTokenAddress(chainId, symbol) {
+  const tokens = FUND_TOKENS[chainId];
+  if (!tokens) {
+    throw new Error(`No fund tokens for chain ${chainId}`);
+  }
+  const addr = tokens[symbol.toUpperCase()];
+  if (!addr) {
+    throw new Error(`Unknown fund token: ${symbol}. Supported: ${Object.keys(tokens).join(", ")}`);
+  }
+  return addr;
+}
+
+// src/services/campaign-create.ts
+function getProvider2(chainId) {
+  return new JsonRpcProvider(getRpc(chainId), chainId, { staticNetwork: true, batchMaxCount: 1 });
+}
+function buildManifest(params) {
+  const base = {
+    exchange: params.exchange,
+    start_date: params.startDate,
+    end_date: params.endDate
+  };
+  switch (params.type) {
+    case "MARKET_MAKING":
+      return JSON.stringify({
+        ...base,
+        type: params.type,
+        pair: params.pair,
+        daily_volume_target: params.dailyVolumeTarget
+      });
+    case "HOLDING":
+      return JSON.stringify({
+        ...base,
+        type: params.type,
+        symbol: params.symbol,
+        daily_balance_target: params.dailyBalanceTarget
+      });
+    case "THRESHOLD":
+      return JSON.stringify({
+        ...base,
+        type: params.type,
+        symbol: params.symbol,
+        minimum_balance_target: params.minimumBalanceTarget
+      });
+    default:
+      throw new Error(`Unknown campaign type: ${params.type}`);
+  }
+}
+function hashManifest(manifest) {
+  return createHash2("sha1").update(manifest).digest("hex");
+}
+async function createCampaign(privateKey, chainId, params) {
+  const contracts = getContracts(chainId);
+  const provider = getProvider2(chainId);
+  const wallet = new Wallet(privateKey, provider);
+  const tokenAddress = getFundTokenAddress(chainId, params.fundToken);
+  const hmtContract = new Contract(tokenAddress, ERC20_ABI, wallet);
+  const decimals = await hmtContract.getFunction("decimals")();
+  const fundAmountWei = parseUnits(params.fundAmount, decimals);
+  const allowance = await hmtContract.getFunction("allowance")(wallet.address, contracts.escrowFactory);
+  if (allowance < fundAmountWei) {
+    const approveTx = await hmtContract.getFunction("approve")(contracts.escrowFactory, fundAmountWei);
+    await approveTx.wait();
+  }
+  const manifest = buildManifest(params);
+  const manifestHash = hashManifest(manifest);
+  const factory = new Contract(contracts.escrowFactory, ESCROW_FACTORY_ABI, wallet);
+  const tx = await factory.getFunction("createFundAndSetupEscrow")(tokenAddress, fundAmountWei, "hufi-campaign-launcher", ORACLES.reputationOracle, ORACLES.recordingOracle, ORACLES.exchangeOracle, manifest, manifestHash);
+  const receipt = await tx.wait();
+  const iface = factory.interface;
+  let escrowAddress = "";
+  for (const log of receipt.logs) {
+    try {
+      const parsed = iface.parseLog({ topics: log.topics, data: log.data });
+      if (parsed?.name === "LaunchedV2") {
+        escrowAddress = parsed.args.escrow;
+        break;
+      }
+    } catch {}
+  }
+  return {
+    escrowAddress: escrowAddress || "unknown",
+    txHash: receipt.hash
+  };
+}
+
 // src/services/launcher/campaign.ts
 async function listLauncherCampaigns(baseUrl, chainId, limit = 20, status = "active") {
   const url = `${baseUrl}/campaigns?chain_id=${chainId}&status=${status}&limit=${limit}`;
@@ -24501,6 +24700,79 @@ async function getLauncherCampaign(baseUrl, chainId, campaignAddress) {
   return await requestJson(url);
 }
 
+// src/services/staking.ts
+var STAKING_ABI = [
+  "function getAvailableStake(address _staker) external view returns (uint256)",
+  "function getStakedTokens(address _staker) external view returns (uint256)",
+  "function minimumStake() external view returns (uint256)",
+  "function lockPeriod() external view returns (uint32)",
+  "function stake(uint256 _tokens) external",
+  "function unstake(uint256 _tokens) external",
+  "function withdraw() external"
+];
+function getProvider3(chainId) {
+  return new JsonRpcProvider(getRpc(chainId), chainId, { staticNetwork: true, batchMaxCount: 1 });
+}
+async function getStakingInfo(address, chainId) {
+  const contracts = getContracts(chainId);
+  const provider = getProvider3(chainId);
+  const stakingContract = new Contract(contracts.staking, STAKING_ABI, provider);
+  const hmtContract = new Contract(contracts.hmt, ERC20_ABI, provider);
+  const [stakedTokens, availableStake, minimumStake, lockPeriod, hmtBalance] = await Promise.all([
+    stakingContract.getFunction("getStakedTokens")(address),
+    stakingContract.getFunction("getAvailableStake")(address),
+    stakingContract.getFunction("minimumStake")(),
+    stakingContract.getFunction("lockPeriod")(),
+    hmtContract.getFunction("balanceOf")(address)
+  ]);
+  const lockedTokens = stakedTokens > availableStake ? stakedTokens - availableStake : 0n;
+  return {
+    stakedTokens: formatUnits(stakedTokens, 18),
+    availableStake: formatUnits(availableStake, 18),
+    lockedTokens: formatUnits(lockedTokens, 18),
+    unlockBlock: 0,
+    minimumStake: formatUnits(minimumStake, 18),
+    lockPeriod: Number(lockPeriod),
+    hmtBalance: formatUnits(hmtBalance, 18),
+    chainId
+  };
+}
+async function stakeHMT(privateKey, amount, chainId) {
+  const contracts = getContracts(chainId);
+  const provider = getProvider3(chainId);
+  const wallet = new Wallet(privateKey, provider);
+  const stakingContract = new Contract(contracts.staking, STAKING_ABI, wallet);
+  const hmtContract = new Contract(contracts.hmt, ERC20_ABI, wallet);
+  const amountWei = parseUnits(amount, 18);
+  const allowance = await hmtContract.getFunction("allowance")(wallet.address, contracts.staking);
+  if (allowance < amountWei) {
+    const approveTx = await hmtContract.getFunction("approve")(contracts.staking, amountWei);
+    await approveTx.wait();
+  }
+  const tx = await stakingContract.getFunction("stake")(amountWei);
+  const receipt = await tx.wait();
+  return receipt.hash;
+}
+async function unstakeHMT(privateKey, amount, chainId) {
+  const contracts = getContracts(chainId);
+  const provider = getProvider3(chainId);
+  const wallet = new Wallet(privateKey, provider);
+  const stakingContract = new Contract(contracts.staking, STAKING_ABI, wallet);
+  const amountWei = parseUnits(amount, 18);
+  const tx = await stakingContract.getFunction("unstake")(amountWei);
+  const receipt = await tx.wait();
+  return receipt.hash;
+}
+async function withdrawHMT(privateKey, chainId) {
+  const contracts = getContracts(chainId);
+  const provider = getProvider3(chainId);
+  const wallet = new Wallet(privateKey, provider);
+  const stakingContract = new Contract(contracts.staking, STAKING_ABI, wallet);
+  const tx = await stakingContract.getFunction("withdraw")();
+  const receipt = await tx.wait();
+  return receipt.hash;
+}
+
 // src/commands/campaign.ts
 function requireAuth2() {
   const config = loadConfig();
@@ -24731,120 +25003,103 @@ function createCampaignCommand() {
       process.exitCode = 1;
     }
   });
+  const VALID_TYPES = ["market_making", "holding", "threshold"];
+  campaign.command("create").description("Create a new campaign (launch escrow on-chain)").requiredOption("--type <type>", `Campaign type (${VALID_TYPES.join(", ")})`).requiredOption("--exchange <name>", "Exchange name (e.g. mexc, bybit)").requiredOption("--symbol <symbol>", "Token symbol or pair (e.g. HMT/USDT or HMT)").requiredOption("--start-date <date>", "Start date (YYYY-MM-DD)").requiredOption("--end-date <date>", "End date (YYYY-MM-DD)").requiredOption("--fund-token <token>", "Fund token (USDT or USDC)").requiredOption("--fund-amount <amount>", "Fund amount").option("--daily-volume-target <n>", "Daily volume target (market_making)", Number).option("--daily-balance-target <n>", "Daily balance target (holding)", Number).option("--minimum-balance-target <n>", "Minimum balance target (threshold)", Number).option("-c, --chain-id <id>", "Chain ID (default: from config)", Number, getDefaultChainId()).option("--json", "Output as JSON").action(async (opts) => {
+    const privateKey = loadKey();
+    if (!privateKey) {
+      printText("No private key found. Run: hufi auth generate");
+      process.exit(1);
+    }
+    const config = loadConfig();
+    const address = config.address;
+    if (!address) {
+      printText("Not authenticated. Run: hufi auth login --private-key <key>");
+      process.exit(1);
+    }
+    const type = opts.type.toLowerCase();
+    if (!VALID_TYPES.includes(type)) {
+      printText(`Invalid type: ${opts.type}. Must be one of: ${VALID_TYPES.join(", ")}`);
+      process.exit(1);
+    }
+    const typeMap = {
+      market_making: "MARKET_MAKING",
+      holding: "HOLDING",
+      threshold: "THRESHOLD"
+    };
+    const startDate = new Date(opts.startDate);
+    const endDate = new Date(opts.endDate);
+    const durationHours = (endDate.getTime() - startDate.getTime()) / (1000 * 60 * 60);
+    if (isNaN(startDate.getTime()) || isNaN(endDate.getTime())) {
+      printText("Invalid date format. Use YYYY-MM-DD.");
+      process.exit(1);
+    }
+    if (durationHours < 6) {
+      printText("Campaign duration must be at least 6 hours.");
+      process.exit(1);
+    }
+    if (durationHours > 100 * 24) {
+      printText("Campaign duration must be at most 100 days.");
+      process.exit(1);
+    }
+    if (type === "market_making" && !opts.dailyVolumeTarget) {
+      printText("--daily-volume-target is required for market_making campaigns.");
+      process.exit(1);
+    }
+    if (type === "holding" && !opts.dailyBalanceTarget) {
+      printText("--daily-balance-target is required for holding campaigns.");
+      process.exit(1);
+    }
+    if (type === "threshold" && !opts.minimumBalanceTarget) {
+      printText("--minimum-balance-target is required for threshold campaigns.");
+      process.exit(1);
+    }
+    try {
+      const stakingInfo = await getStakingInfo(address, opts.chainId);
+      if (Number(stakingInfo.stakedTokens) <= 0) {
+        printText("You must stake HMT before creating a campaign.");
+        printText("Run: hufi staking stake -a <amount>");
+        process.exit(1);
+      }
+    } catch {
+      printText("Warning: could not verify staking status.");
+    }
+    const params = {
+      type: typeMap[type],
+      exchange: opts.exchange,
+      pair: type === "market_making" ? opts.symbol : undefined,
+      symbol: type !== "market_making" ? opts.symbol : undefined,
+      startDate: startDate.toISOString(),
+      endDate: endDate.toISOString(),
+      fundToken: opts.fundToken.toUpperCase(),
+      fundAmount: opts.fundAmount,
+      dailyVolumeTarget: opts.dailyVolumeTarget,
+      dailyBalanceTarget: opts.dailyBalanceTarget,
+      minimumBalanceTarget: opts.minimumBalanceTarget
+    };
+    try {
+      printText(`Creating ${type} campaign on ${opts.exchange}...`);
+      printText(`  Fund: ${opts.fundAmount} ${opts.fundToken}`);
+      printText(`  Duration: ${opts.startDate} ~ ${opts.endDate}`);
+      printText("");
+      const result = await createCampaign(privateKey, opts.chainId, params);
+      if (opts.json) {
+        printJson(result);
+      } else {
+        printText(`Campaign created successfully!`);
+        printText(`  Escrow: ${result.escrowAddress}`);
+        printText(`  TX:     ${result.txHash}`);
+      }
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      printText(`Failed to create campaign: ${message}`);
+      process.exitCode = 1;
+    }
+  });
   return campaign;
 }
 
 // src/commands/staking.ts
 var import_qrcode = __toESM(require_server(), 1);
-
-// src/services/staking.ts
-var STAKING_CONTRACTS = {
-  137: {
-    staking: "0x01D115E9E8bF0C58318793624CC662a030D07F1D",
-    hmt: "0xc748B2A084F8eFc47E086ccdDD9b7e67aEb571BF",
-    rpcs: [
-      "https://polygon.drpc.org",
-      "https://rpc.ankr.com/polygon",
-      "https://polygon-mainnet.public.blastapi.io"
-    ]
-  },
-  1: {
-    staking: "0x86Af9f6Cd34B69Db1B202223C6d6D109f2491569",
-    hmt: "0xd1ba9BAC957322D6e8c07a160a3A8dA11A0d2867",
-    rpcs: [
-      "https://eth.drpc.org",
-      "https://rpc.ankr.com/eth",
-      "https://ethereum-rpc.publicnode.com"
-    ]
-  }
-};
-var STAKING_ABI = [
-  "function getAvailableStake(address _staker) external view returns (uint256)",
-  "function getStakedTokens(address _staker) external view returns (uint256)",
-  "function minimumStake() external view returns (uint256)",
-  "function lockPeriod() external view returns (uint32)",
-  "function stake(uint256 _tokens) external",
-  "function unstake(uint256 _tokens) external",
-  "function withdraw() external"
-];
-var ERC20_ABI = [
-  "function balanceOf(address) external view returns (uint256)",
-  "function allowance(address owner, address spender) external view returns (uint256)",
-  "function approve(address spender, uint256 amount) external returns (bool)",
-  "function decimals() external view returns (uint8)"
-];
-function getProvider2(chainId) {
-  const config = getConfig(chainId);
-  return new JsonRpcProvider(config.rpcs[0], chainId, { staticNetwork: true, batchMaxCount: 1 });
-}
-function getConfig(chainId) {
-  const config = STAKING_CONTRACTS[chainId];
-  if (!config) {
-    throw new Error(`Unsupported chain ID: ${chainId}. Supported: ${Object.keys(STAKING_CONTRACTS).join(", ")}`);
-  }
-  return config;
-}
-async function getStakingInfo(address, chainId) {
-  const config = getConfig(chainId);
-  const provider = getProvider2(chainId);
-  const stakingContract = new Contract(config.staking, STAKING_ABI, provider);
-  const hmtContract = new Contract(config.hmt, ERC20_ABI, provider);
-  const [stakedTokens, availableStake, minimumStake, lockPeriod, hmtBalance] = await Promise.all([
-    stakingContract.getFunction("getStakedTokens")(address),
-    stakingContract.getFunction("getAvailableStake")(address),
-    stakingContract.getFunction("minimumStake")(),
-    stakingContract.getFunction("lockPeriod")(),
-    hmtContract.getFunction("balanceOf")(address)
-  ]);
-  const lockedTokens = stakedTokens > availableStake ? stakedTokens - availableStake : 0n;
-  return {
-    stakedTokens: formatUnits(stakedTokens, 18),
-    availableStake: formatUnits(availableStake, 18),
-    lockedTokens: formatUnits(lockedTokens, 18),
-    unlockBlock: 0,
-    minimumStake: formatUnits(minimumStake, 18),
-    lockPeriod: Number(lockPeriod),
-    hmtBalance: formatUnits(hmtBalance, 18),
-    chainId
-  };
-}
-async function stakeHMT(privateKey, amount, chainId) {
-  const config = getConfig(chainId);
-  const provider = getProvider2(chainId);
-  const wallet = new Wallet(privateKey, provider);
-  const stakingContract = new Contract(config.staking, STAKING_ABI, wallet);
-  const hmtContract = new Contract(config.hmt, ERC20_ABI, wallet);
-  const amountWei = parseUnits(amount, 18);
-  const allowance = await hmtContract.getFunction("allowance")(wallet.address, config.staking);
-  if (allowance < amountWei) {
-    const approveTx = await hmtContract.getFunction("approve")(config.staking, amountWei);
-    await approveTx.wait();
-  }
-  const tx = await stakingContract.getFunction("stake")(amountWei);
-  const receipt = await tx.wait();
-  return receipt.hash;
-}
-async function unstakeHMT(privateKey, amount, chainId) {
-  const config = getConfig(chainId);
-  const provider = getProvider2(chainId);
-  const wallet = new Wallet(privateKey, provider);
-  const stakingContract = new Contract(config.staking, STAKING_ABI, wallet);
-  const amountWei = parseUnits(amount, 18);
-  const tx = await stakingContract.getFunction("unstake")(amountWei);
-  const receipt = await tx.wait();
-  return receipt.hash;
-}
-async function withdrawHMT(privateKey, chainId) {
-  const config = getConfig(chainId);
-  const provider = getProvider2(chainId);
-  const wallet = new Wallet(privateKey, provider);
-  const stakingContract = new Contract(config.staking, STAKING_ABI, wallet);
-  const tx = await stakingContract.getFunction("withdraw")();
-  const receipt = await tx.wait();
-  return receipt.hash;
-}
-
-// src/commands/staking.ts
 function requireKey() {
   const key = loadKey();
   if (!key) {
@@ -24959,9 +25214,89 @@ Send HMT to this address on Polygon (chain 137) or Ethereum (chain 1).`);
   return staking;
 }
 
+// src/commands/dashboard.ts
+function requireAuth3() {
+  const config = loadConfig();
+  if (!config.accessToken || !config.address) {
+    printText("Not authenticated. Run: hufi auth login --private-key <key>");
+    process.exit(1);
+  }
+  return {
+    baseUrl: config.recordingApiUrl.replace(/\/+$/, ""),
+    accessToken: config.accessToken,
+    address: config.address
+  };
+}
+function createDashboardCommand() {
+  const dashboard = new Command("dashboard").description("Portfolio overview — staking, campaigns, and earnings").option("-c, --chain-id <id>", "Chain ID (default: from config)", Number, getDefaultChainId()).option("--json", "Output as JSON").action(async (opts) => {
+    const { baseUrl, accessToken, address } = requireAuth3();
+    try {
+      const [stakingInfo, campaignsResult] = await Promise.all([
+        getStakingInfo(address, opts.chainId).catch(() => null),
+        listJoinedCampaigns(baseUrl, accessToken, 50).catch(() => null)
+      ]);
+      const campaigns = campaignsResult?.results ?? [];
+      const activeCampaigns = campaigns.filter((c) => {
+        const r = c;
+        return r.status === "active" || r.status === "ACTIVE";
+      });
+      const progressPromises = activeCampaigns.map(async (c) => {
+        const r = c;
+        const chainId = r.chain_id ?? opts.chainId;
+        const campaignAddress = r.address ?? r.escrow_address ?? "";
+        if (!campaignAddress)
+          return { campaign: c, progress: null };
+        try {
+          const progress = await getMyProgress(baseUrl, accessToken, chainId, campaignAddress);
+          return { campaign: c, progress };
+        } catch {
+          return { campaign: c, progress: null };
+        }
+      });
+      const progressResults = await Promise.all(progressPromises);
+      if (opts.json) {
+        printJson({
+          address,
+          chainId: opts.chainId,
+          staking: stakingInfo,
+          activeCampaigns: progressResults
+        });
+        return;
+      }
+      printText(`Wallet: ${address}  Chain: ${opts.chainId}
+`);
+      if (stakingInfo) {
+        printText("Staking");
+        printText(`  Staked:     ${Number(stakingInfo.stakedTokens).toLocaleString()} HMT`);
+        printText(`  Available:  ${Number(stakingInfo.availableStake).toLocaleString()} HMT`);
+        printText(`  Balance:    ${Number(stakingInfo.hmtBalance).toLocaleString()} HMT`);
+        printText("");
+      }
+      if (activeCampaigns.length === 0) {
+        printText("No active campaigns.");
+      } else {
+        printText(`Active Campaigns (${activeCampaigns.length})`);
+        for (const { campaign, progress } of progressResults) {
+          const r = campaign;
+          const exchange = r.exchange_name ?? "?";
+          const symbol = r.symbol ?? "?";
+          const type = r.type ?? "?";
+          const score = progress && typeof progress === "object" && "my_score" in progress ? `  score: ${progress.my_score}` : "";
+          printText(`  ${exchange} ${symbol} (${type})${score}`);
+        }
+      }
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      printText(`Failed to load dashboard: ${message}`);
+      process.exitCode = 1;
+    }
+  });
+  return dashboard;
+}
+
 // src/cli.ts
 var program2 = new Command;
-program2.name("hufi").description("CLI tool for hu.fi DeFi platform").version("0.6.1").option("--config-file <path>", "Custom config file path (default: ~/.hufi-cli/config.json)").option("--key-file <path>", "Custom key file path (default: ~/.hufi-cli/key.json)").hook("preAction", (thisCommand) => {
+program2.name("hufi").description("CLI tool for hu.fi DeFi platform").version("0.8.1").option("--config-file <path>", "Custom config file path (default: ~/.hufi-cli/config.json)").option("--key-file <path>", "Custom key file path (default: ~/.hufi-cli/key.json)").hook("preAction", (thisCommand) => {
   const opts = thisCommand.opts();
   if (opts.configFile) {
     setConfigFile(opts.configFile);
@@ -24974,4 +25309,5 @@ program2.addCommand(createAuthCommand());
 program2.addCommand(createExchangeCommand());
 program2.addCommand(createCampaignCommand());
 program2.addCommand(createStakingCommand());
+program2.addCommand(createDashboardCommand());
 program2.parse();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hufi-cli",
-  "version": "0.6.1",
+  "version": "0.8.1",
   "type": "module",
   "bin": {
     "hufi": "./dist/cli.js"