hufi-cli 0.6.1 → 1.0.0

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
@@ -64,9 +65,38 @@ hufi campaign get --chain-id 137 --address 0x...            # campaign details
 hufi campaign join --address 0x...                          # join (chain-id defaults to 137)
 hufi campaign status --address 0x...                        # check status
 hufi campaign progress --address 0x...                      # your progress
+hufi campaign progress --address 0x... --watch              # live updates (polling)
+hufi campaign progress --address 0x... --watch --interval 3000
 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 +105,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 +136,17 @@ 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
+hufi dashboard --export csv # export active campaign rows as CSV
+hufi dashboard --export json
+```
+
 ## Global Options
 
 | Option | Description |

package/dist/cli.js

@@ -22697,28 +22697,62 @@ class ApiError extends Error {
 }
 
 // src/lib/http.ts
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function isRetryableStatus(status) {
+  return status === 408 || status === 429 || status >= 500;
+}
+function resolveMessage(payload, status) {
+  let message = `HTTP ${status}`;
+  if (payload && typeof payload === "object" && "message" in payload) {
+    message = String(payload.message);
+  } else if (typeof payload === "string" && payload) {
+    message = payload;
+  }
+  return message;
+}
 async function requestJson(url, options = {}) {
-  const response = await fetch(url, {
-    method: options.method ?? "GET",
-    headers: {
-      "Content-Type": "application/json",
-      ...options.headers ?? {}
-    },
-    body: options.body
-  });
-  const contentType = response.headers.get("content-type") ?? "";
-  const isJson = contentType.includes("application/json");
-  const payload = isJson ? await response.json() : await response.text();
-  if (!response.ok) {
-    let message = `HTTP ${response.status}`;
-    if (payload && typeof payload === "object" && "message" in payload) {
-      message = String(payload.message);
-    } else if (typeof payload === "string" && payload) {
-      message = payload;
+  const retries = options.retry?.retries ?? 2;
+  const initialDelayMs = options.retry?.initialDelayMs ?? 250;
+  const maxDelayMs = options.retry?.maxDelayMs ?? 3000;
+  let attempt = 0;
+  while (true) {
+    try {
+      const response = await fetch(url, {
+        method: options.method ?? "GET",
+        headers: {
+          "Content-Type": "application/json",
+          ...options.headers ?? {}
+        },
+        body: options.body
+      });
+      const contentType = response.headers.get("content-type") ?? "";
+      const isJson = contentType.includes("application/json");
+      const payload = isJson ? await response.json() : await response.text();
+      if (!response.ok) {
+        const message = resolveMessage(payload, response.status);
+        if (isRetryableStatus(response.status) && attempt < retries) {
+          const delay = Math.min(initialDelayMs * 2 ** attempt, maxDelayMs);
+          attempt += 1;
+          await sleep(delay);
+          continue;
+        }
+        throw new ApiError(message, response.status, payload);
+      }
+      return payload;
+    } catch (err) {
+      if (err instanceof ApiError) {
+        throw err;
+      }
+      if (attempt >= retries) {
+        throw err;
+      }
+      const delay = Math.min(initialDelayMs * 2 ** attempt, maxDelayMs);
+      attempt += 1;
+      await sleep(delay);
     }
-    throw new ApiError(message, response.status, payload);
   }
-  return payload;
 }
 function authHeaders(accessToken) {
   return { Authorization: `Bearer ${accessToken}` };
@@ -22840,6 +22874,38 @@ function loadKey() {
     return null;
   }
 }
+function isHttpUrl(value) {
+  try {
+    const parsed = new URL(value);
+    return parsed.protocol === "http:" || parsed.protocol === "https:";
+  } catch {
+    return false;
+  }
+}
+function isEvmAddress(value) {
+  return /^0x[a-fA-F0-9]{40}$/.test(value);
+}
+function validateConfig(config) {
+  const issues = [];
+  if (config.recordingApiUrl !== undefined && !isHttpUrl(config.recordingApiUrl)) {
+    issues.push("recordingApiUrl must be a valid http/https URL");
+  }
+  if (config.launcherApiUrl !== undefined && !isHttpUrl(config.launcherApiUrl)) {
+    issues.push("launcherApiUrl must be a valid http/https URL");
+  }
+  if (config.defaultChainId !== undefined) {
+    if (!Number.isInteger(config.defaultChainId) || config.defaultChainId <= 0) {
+      issues.push("defaultChainId must be a positive integer");
+    }
+  }
+  if (config.address !== undefined && !isEvmAddress(config.address)) {
+    issues.push("address must be a valid 0x-prefixed EVM address");
+  }
+  return {
+    valid: issues.length === 0,
+    issues
+  };
+}
 
 // src/lib/output.ts
 function printJson(data) {
@@ -22958,9 +23024,21 @@ 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() {
+// src/lib/require-auth.ts
+function requireAuthToken() {
   const config = loadConfig();
   if (!config.accessToken) {
     printText("Not authenticated. Run: hufi auth login --private-key <key>");
@@ -22971,10 +23049,24 @@ function requireAuth() {
     accessToken: config.accessToken
   };
 }
+function requireAuthAddress() {
+  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
+  };
+}
+
+// src/commands/exchange.ts
 function createExchangeCommand() {
   const exchange = new Command("exchange").description("Exchange API key management");
   exchange.command("register").description("Register a read-only exchange API key").requiredOption("-n, --name <name>", "Exchange name (e.g. binance, mexc)").requiredOption("--api-key <key>", "Read-only API key").requiredOption("--secret-key <key>", "Read-only API secret").option("--bitmart-memo <memo>", "Bitmart memo (only for bitmart)").option("--json", "Output as JSON").action(async (opts) => {
-    const { baseUrl, accessToken } = requireAuth();
+    const { baseUrl, accessToken } = requireAuthToken();
     try {
       const result = await registerExchangeApiKey(baseUrl, accessToken, opts.name, opts.apiKey, opts.secretKey, opts.bitmartMemo);
       if (opts.json) {
@@ -22992,7 +23084,7 @@ function createExchangeCommand() {
     }
   });
   exchange.command("list").description("List registered exchange API keys").option("--json", "Output as JSON").action(async (opts) => {
-    const { baseUrl, accessToken } = requireAuth();
+    const { baseUrl, accessToken } = requireAuthToken();
     try {
       const keys = await listExchangeApiKeys(baseUrl, accessToken);
       if (opts.json) {
@@ -23013,6 +23105,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 } = requireAuthToken();
+    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 } = requireAuthToken();
+    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,9 +24617,258 @@ 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/blockchain.ts
+function sleep2(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function waitForConfirmations(provider, txHash, opts = {}) {
+  const minConfirmations = opts.minConfirmations ?? 1;
+  const pollMs = opts.pollMs ?? 3000;
+  const timeoutMs = opts.timeoutMs ?? 120000;
+  const started = Date.now();
+  while (Date.now() - started <= timeoutMs) {
+    const receipt = await provider.getTransactionReceipt(txHash);
+    if (!receipt) {
+      await sleep2(pollMs);
+      continue;
+    }
+    let confirmations = 0;
+    if (typeof receipt.confirmations === "function") {
+      confirmations = await receipt.confirmations();
+    } else {
+      confirmations = receipt.confirmations ?? 0;
+    }
+    opts.onProgress?.(confirmations);
+    if (confirmations >= minConfirmations) {
+      return receipt;
+    }
+    await sleep2(pollMs);
+  }
+  throw new Error(`Timed out waiting for transaction confirmation: ${txHash}`);
+}
+function estimateGasWithBuffer(estimated, bps = 1200) {
+  return estimated * BigInt(1e4 + bps) / BigInt(1e4);
+}
+
+// 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
+var CHAIN_NATIVE_SYMBOL = {
+  137: "MATIC",
+  1: "ETH"
+};
+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 preflightCampaign(privateKey, chainId, params) {
+  const contracts = getContracts(chainId);
+  const provider = getProvider2(chainId);
+  const wallet = new Wallet(privateKey, provider);
+  const tokenAddress = getFundTokenAddress(chainId, params.fundToken);
+  const fundTokenContract = new Contract(tokenAddress, ERC20_ABI, wallet);
+  const [decimals, balance, allowance, nativeBalance, gasPrice] = await Promise.all([
+    fundTokenContract.getFunction("decimals")(),
+    fundTokenContract.getFunction("balanceOf")(wallet.address),
+    fundTokenContract.getFunction("allowance")(wallet.address, contracts.escrowFactory),
+    provider.getBalance(wallet.address),
+    provider.getFeeData().then((d) => d.gasPrice ?? 0n)
+  ]);
+  const fundAmountWei = parseUnits(params.fundAmount, decimals);
+  const needsApproval = allowance < fundAmountWei;
+  const manifest = buildManifest(params);
+  const manifestHash = hashManifest(manifest);
+  const factory = new Contract(contracts.escrowFactory, ESCROW_FACTORY_ABI, wallet);
+  const [approveGasEstimate, createGasEstimate] = await Promise.all([
+    needsApproval ? fundTokenContract.getFunction("approve").estimateGas(contracts.escrowFactory, fundAmountWei) : Promise.resolve(0n),
+    factory.getFunction("createFundAndSetupEscrow").estimateGas(tokenAddress, fundAmountWei, "hufi-campaign-launcher", ORACLES.reputationOracle, ORACLES.recordingOracle, ORACLES.exchangeOracle, manifest, manifestHash)
+  ]);
+  return {
+    needsApproval,
+    fundTokenBalance: balance,
+    fundTokenDecimals: decimals,
+    fundTokenSymbol: params.fundToken.toUpperCase(),
+    approveGasEstimate,
+    createGasEstimate,
+    nativeBalance,
+    gasPrice
+  };
+}
+function estimateTotalGasCost(result, chainId) {
+  const totalGasUnits = (result.needsApproval ? result.approveGasEstimate : 0n) + result.createGasEstimate;
+  const bufferedGasUnits = estimateGasWithBuffer(totalGasUnits);
+  const totalGasWei = bufferedGasUnits * result.gasPrice;
+  const nativeSymbol = CHAIN_NATIVE_SYMBOL[chainId] ?? "ETH";
+  return {
+    totalGasWei,
+    nativeSymbol,
+    insufficientNative: result.nativeBalance < totalGasWei
+  };
+}
+async function createCampaign(privateKey, chainId, params, onConfirmationProgress) {
+  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 approveEstimate = await hmtContract.getFunction("approve").estimateGas(contracts.escrowFactory, fundAmountWei);
+    const approveTx = await hmtContract.getFunction("approve")(contracts.escrowFactory, fundAmountWei, { gasLimit: estimateGasWithBuffer(approveEstimate) });
+    await waitForConfirmations(provider, approveTx.hash, { minConfirmations: 1 });
+  }
+  const manifest = buildManifest(params);
+  const manifestHash = hashManifest(manifest);
+  const factory = new Contract(contracts.escrowFactory, ESCROW_FACTORY_ABI, wallet);
+  const createEstimate = await factory.getFunction("createFundAndSetupEscrow").estimateGas(tokenAddress, fundAmountWei, "hufi-campaign-launcher", ORACLES.reputationOracle, ORACLES.recordingOracle, ORACLES.exchangeOracle, manifest, manifestHash);
+  const tx = await factory.getFunction("createFundAndSetupEscrow")(tokenAddress, fundAmountWei, "hufi-campaign-launcher", ORACLES.reputationOracle, ORACLES.recordingOracle, ORACLES.exchangeOracle, manifest, manifestHash, { gasLimit: estimateGasWithBuffer(createEstimate) });
+  const receipt = await waitForConfirmations(provider, tx.hash, {
+    minConfirmations: 1,
+    onProgress: (confirmations2) => {
+      onConfirmationProgress?.(confirmations2);
+    }
+  });
+  let confirmations = 1;
+  if (typeof receipt.confirmations === "function") {
+    confirmations = await receipt.confirmations();
+  } else {
+    confirmations = receipt.confirmations ?? 1;
+  }
+  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,
+    status: "confirmed",
+    confirmations
+  };
+}
+
 // 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}`;
+async function listLauncherCampaigns(baseUrl, chainId, limit = 20, status = "active", page = 1) {
+  const url = `${baseUrl}/campaigns?chain_id=${chainId}&status=${status}&limit=${limit}&page=${page}`;
   return await requestJson(url);
 }
 async function getLauncherCampaign(baseUrl, chainId, campaignAddress) {
@@ -24501,29 +24876,113 @@ async function getLauncherCampaign(baseUrl, chainId, campaignAddress) {
   return await requestJson(url);
 }
 
-// src/commands/campaign.ts
-function requireAuth2() {
-  const config = loadConfig();
-  if (!config.accessToken || !config.address) {
-    printText("Not authenticated. Run: hufi auth login --private-key <key>");
-    process.exit(1);
-  }
+// 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 {
-    baseUrl: config.recordingApiUrl.replace(/\/+$/, ""),
-    accessToken: config.accessToken,
-    address: config.address
+    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/lib/watch.ts
+function sleep3(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function runWatchLoop(fn, options = {}) {
+  const intervalMs = options.intervalMs ?? 1e4;
+  const shouldContinue = options.shouldContinue ?? (() => true);
+  while (shouldContinue()) {
+    await fn();
+    if (!shouldContinue()) {
+      break;
+    }
+    await sleep3(intervalMs);
+  }
+}
+
+// src/commands/campaign.ts
+function formatCampaignCreateProgress(confirmations) {
+  if (confirmations <= 0) {
+    return "Transaction submitted. Waiting for confirmations...";
+  }
+  return `Confirmations: ${confirmations}`;
+}
 function getLauncherUrl() {
   const config = loadConfig();
   return (config.launcherApiUrl ?? "https://cl.hu.finance").replace(/\/+$/, "");
 }
 function createCampaignCommand() {
   const campaign = new Command("campaign").description("Campaign management commands");
-  campaign.command("list").description("List available campaigns").option("-c, --chain-id <id>", "Chain ID (default: from config)", Number, getDefaultChainId()).option("-s, --status <status>", "Filter by status (active, completed, cancelled, to_cancel)", "active").option("-l, --limit <n>", "Max results", Number, 20).option("--json", "Output as JSON").action(async (opts) => {
+  campaign.command("list").description("List available campaigns").option("-c, --chain-id <id>", "Chain ID (default: from config)", Number, getDefaultChainId()).option("-s, --status <status>", "Filter by status (active, completed, cancelled, to_cancel)", "active").option("--page <n>", "Page number", Number, 1).option("--page-size <n>", "Items per page", Number, 20).option("-l, --limit <n>", "Max results", Number, 20).option("--json", "Output as JSON").action(async (opts) => {
     const config = loadConfig();
     try {
-      const launcherResult = await listLauncherCampaigns(getLauncherUrl(), opts.chainId, opts.limit, opts.status);
+      const pageSize = opts.pageSize ?? opts.limit;
+      const launcherResult = await listLauncherCampaigns(getLauncherUrl(), opts.chainId, pageSize, opts.status, opts.page);
       let joinedKeys = new Set;
       if (config.accessToken) {
         const recordingUrl = config.recordingApiUrl.replace(/\/+$/, "");
@@ -24567,6 +25026,9 @@ function createCampaignCommand() {
           if (opts.status === "active") {
             printText("Tip: use --status completed, --status cancelled, or --status to_cancel to see other campaigns.");
           }
+          if (launcherResult.has_more) {
+            printText(`Tip: more campaigns available, try --page ${opts.page + 1} --page-size ${pageSize}.`);
+          }
         }
       }
     } catch (err) {
@@ -24601,7 +25063,7 @@ function createCampaignCommand() {
     }
   });
   campaign.command("joined").description("List campaigns you have joined").option("-l, --limit <n>", "Max results", Number, 20).option("--json", "Output as JSON").action(async (opts) => {
-    const { baseUrl, accessToken } = requireAuth2();
+    const { baseUrl, accessToken } = requireAuthAddress();
     try {
       const result = await listJoinedCampaigns(baseUrl, accessToken, opts.limit);
       if (opts.json) {
@@ -24629,7 +25091,7 @@ function createCampaignCommand() {
       statusCmd.help();
       return;
     }
-    const { baseUrl, accessToken } = requireAuth2();
+    const { baseUrl, accessToken } = requireAuthAddress();
     try {
       const status = await checkJoinStatus(baseUrl, accessToken, opts.chainId, opts.address);
       if (opts.json) {
@@ -24652,7 +25114,7 @@ function createCampaignCommand() {
       joinCmd.help();
       return;
     }
-    const { baseUrl, accessToken } = requireAuth2();
+    const { baseUrl, accessToken } = requireAuthAddress();
     try {
       const joinStatus = await checkJoinStatus(baseUrl, accessToken, opts.chainId, opts.address);
       if (joinStatus.status === "already_joined") {
@@ -24677,25 +25139,53 @@ function createCampaignCommand() {
       process.exitCode = 1;
     }
   });
-  const progressCmd = campaign.command("progress").description("Check your progress in a campaign").option("-c, --chain-id <id>", "Chain ID (default: from config)", Number, getDefaultChainId()).option("-a, --address <address>", "Campaign escrow address").option("--json", "Output as JSON").action(async (opts) => {
+  const progressCmd = campaign.command("progress").description("Check your progress in a campaign").option("-c, --chain-id <id>", "Chain ID (default: from config)", Number, getDefaultChainId()).option("-a, --address <address>", "Campaign escrow address").option("--watch", "Poll continuously").option("--interval <ms>", "Polling interval in ms", Number, 1e4).option("--json", "Output as JSON").action(async (opts) => {
     if (!opts.address) {
       progressCmd.help();
       return;
     }
-    const { baseUrl, accessToken } = requireAuth2();
+    const { baseUrl, accessToken } = requireAuthAddress();
     try {
-      const result = await getMyProgress(baseUrl, accessToken, opts.chainId, opts.address);
-      if (opts.json) {
-        printJson(result);
-      } else {
-        const r = result;
-        if (r.message) {
-          printText(String(r.message));
+      let running = true;
+      let hasRunOnce = false;
+      let watchStoppedBySignal = false;
+      const stop = () => {
+        running = false;
+        watchStoppedBySignal = true;
+        printText("Stopped watching progress.");
+      };
+      if (opts.watch) {
+        process.once("SIGINT", stop);
+      }
+      await runWatchLoop(async () => {
+        hasRunOnce = true;
+        const result = await getMyProgress(baseUrl, accessToken, opts.chainId, opts.address);
+        if (opts.json) {
+          printJson(result);
         } else {
-          for (const [key, value] of Object.entries(r)) {
-            printText(`  ${key}: ${value}`);
+          const r = result;
+          if (r.message) {
+            printText(String(r.message));
+          } else {
+            for (const [key, value] of Object.entries(r)) {
+              printText(`  ${key}: ${value}`);
+            }
           }
         }
+        if (opts.watch) {
+          printText("---");
+        }
+      }, {
+        intervalMs: opts.interval,
+        shouldContinue: () => opts.watch ? running : !hasRunOnce
+      });
+      if (opts.watch) {
+        process.removeListener("SIGINT", stop);
+        if (watchStoppedBySignal) {
+          process.exitCode = 0;
+        }
+      } else {
+        return;
       }
     } catch (err) {
       const message = err instanceof Error ? err.message : String(err);
@@ -24731,120 +25221,146 @@ 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);
+    }
+    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
+    };
+    let minimumStake = "0";
+    try {
+      const stakingInfo = await getStakingInfo(address, opts.chainId);
+      minimumStake = stakingInfo.minimumStake;
+      if (Number(stakingInfo.stakedTokens) < Number(minimumStake)) {
+        printText("Insufficient staked HMT to create a campaign.");
+        printText(`  Required:  ${Number(minimumStake).toLocaleString()} HMT (minimum stake)`);
+        printText(`  Your stake: ${Number(stakingInfo.stakedTokens).toLocaleString()} HMT`);
+        printText("");
+        printText("Stake more HMT with: hufi staking stake -a <amount>");
+        process.exit(1);
+      }
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      printText(`Warning: could not verify staking status: ${message}`);
+      printText("Proceeding anyway...");
+    }
+    let preflight;
+    try {
+      preflight = await preflightCampaign(privateKey, opts.chainId, params);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      printText(`Preflight check failed: ${message}`);
+      process.exitCode = 1;
+      return;
+    }
+    const fundAmountWei = BigInt(Math.floor(Number(opts.fundAmount) * 10 ** preflight.fundTokenDecimals));
+    if (preflight.fundTokenBalance < fundAmountWei) {
+      printText(`Insufficient ${preflight.fundTokenSymbol} balance.`);
+      printText(`  Required: ${opts.fundAmount} ${preflight.fundTokenSymbol}`);
+      printText(`  Balance:  ${formatUnits(preflight.fundTokenBalance, preflight.fundTokenDecimals)} ${preflight.fundTokenSymbol}`);
+      process.exit(1);
+    }
+    const gasCost = estimateTotalGasCost(preflight, opts.chainId);
+    printText("Campaign creation summary:");
+    printText(`  Type:       ${type} on ${opts.exchange}`);
+    printText(`  Symbol:     ${opts.symbol}`);
+    printText(`  Fund:       ${opts.fundAmount} ${preflight.fundTokenSymbol}`);
+    printText(`  Duration:   ${opts.startDate} ~ ${opts.endDate}`);
+    printText(`  Chain:      ${opts.chainId}`);
+    printText("");
+    printText("Estimated gas costs:");
+    if (preflight.needsApproval) {
+      printText(`  Approval:   ~${preflight.approveGasEstimate.toLocaleString()} gas`);
+    }
+    printText(`  Creation:   ~${preflight.createGasEstimate.toLocaleString()} gas`);
+    printText(`  Total:      ~${formatUnits(gasCost.totalGasWei, 18)} ${gasCost.nativeSymbol}`);
+    printText("");
+    if (gasCost.insufficientNative) {
+      printText(`Insufficient ${gasCost.nativeSymbol} for gas.`);
+      printText(`  Balance: ${formatUnits(preflight.nativeBalance, 18)} ${gasCost.nativeSymbol}`);
+      printText(`  Needed:  ~${formatUnits(gasCost.totalGasWei, 18)} ${gasCost.nativeSymbol}`);
+      process.exit(1);
+    }
+    try {
+      printText(formatCampaignCreateProgress(0));
+      const result = await createCampaign(privateKey, opts.chainId, params, (confirmations) => {
+        printText(formatCampaignCreateProgress(confirmations));
+      });
+      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 +25475,127 @@ Send HMT to this address on Polygon (chain 137) or Ethereum (chain 1).`);
   return staking;
 }
 
+// src/lib/export.ts
+function toCsvRows(rows) {
+  if (rows.length === 0) {
+    return "";
+  }
+  const first = rows[0];
+  if (!first) {
+    return "";
+  }
+  const headers = Object.keys(first);
+  const headerLine = headers.join(",");
+  const lines = rows.map((row) => headers.map((key) => {
+    const value = row[key];
+    const raw = value === null || value === undefined ? "" : String(value);
+    if (raw.includes(",") || raw.includes(`
+`) || raw.includes('"')) {
+      return `"${raw.replaceAll('"', '""')}"`;
+    }
+    return raw;
+  }).join(","));
+  return [headerLine, ...lines].join(`
+`);
+}
+
+// src/commands/dashboard.ts
+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("--export <format>", "Export format: csv|json").option("--json", "Output as JSON").action(async (opts) => {
+    const { baseUrl, accessToken, address } = requireAuthAddress();
+    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);
+      const summary = {
+        address,
+        chainId: opts.chainId,
+        staking: stakingInfo,
+        activeCampaigns: progressResults
+      };
+      if (opts.export) {
+        const format = String(opts.export).toLowerCase();
+        if (format === "json") {
+          printJson(summary);
+          return;
+        }
+        if (format === "csv") {
+          const rows = progressResults.map(({ campaign, progress }) => {
+            const r = campaign;
+            const p = progress ?? {};
+            return {
+              exchange: String(r.exchange_name ?? ""),
+              symbol: String(r.symbol ?? ""),
+              type: String(r.type ?? ""),
+              campaign_address: String(r.address ?? r.escrow_address ?? ""),
+              my_score: String(p.my_score ?? "")
+            };
+          });
+          printText(toCsvRows(rows));
+          return;
+        }
+        printText("Invalid export format. Use csv or json.");
+        process.exitCode = 1;
+        return;
+      }
+      if (opts.json) {
+        printJson(summary);
+        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("1.0.0").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);
@@ -24969,9 +25603,19 @@ program2.name("hufi").description("CLI tool for hu.fi DeFi platform").version("0
   if (opts.keyFile) {
     setKeyFile(opts.keyFile);
   }
+  const validation = validateConfig(loadConfig());
+  if (!validation.valid) {
+    console.error("Invalid configuration:");
+    for (const issue of validation.issues) {
+      console.error(`- ${issue}`);
+    }
+    console.error("Fix config in ~/.hufi-cli/config.json or pass --config-file.");
+    process.exit(1);
+  }
 });
 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": "1.0.0",
   "type": "module",
   "bin": {
     "hufi": "./dist/cli.js"