dipcoin-cli 1.2.2 → 1.3.1

package/README.md

@@ -101,9 +101,12 @@ dipcoin-cli market pairs                    # List all trading pairs
 dipcoin-cli market ticker <symbol>          # Ticker (price, volume, funding)
 dipcoin-cli market orderbook <symbol>       # Order book
 dipcoin-cli market oracle <symbol>          # Oracle price
+dipcoin-cli market kline <symbol>           # Candlestick history (default 1h, last 24h)
+dipcoin-cli market kline BTC --interval 5m --count 20
+dipcoin-cli market kline BTC --interval 1d --from <unix-sec> --to <unix-sec>
 ```
 
-Symbols auto-normalize: `BTC` becomes `BTC-PERP`.
+Symbols auto-normalize: `BTC` becomes `BTC-PERP`. `kline` intervals: `1m / 5m / 15m / 30m / 1h / 4h / 1d / 1w`.
 
 #### account
 
@@ -145,8 +148,14 @@ dipcoin-cli trade orders --symbol BTC-PERP
 
 # Cancel orders
 dipcoin-cli trade cancel <symbol> <hash1> [hash2...]
+
+# Adjust default (ISOLATED) leverage for a market (REST update, no on-chain tx)
+dipcoin-cli trade leverage BTC 10
+dipcoin-cli trade leverage ETH 5
 ```
 
+DipCoin perp currently only supports ISOLATED margin; CROSS is not exposed by the backend.
+
 **Trade Options:**
 
 | Option | Description |
@@ -172,13 +181,19 @@ dipcoin-cli position tpsl <symbol> --side <buy|sell> --quantity <q> --leverage <
 dipcoin-cli position tpsl <symbol> --side sell --quantity 0.01 --leverage 10 \
   --tp-trigger 105000 --tp-type limit --tp-price 105000
 
-# Margin operations (on-chain)
+# Margin operations (on-chain) — auto-prepends a fresh signed price update
 dipcoin-cli position margin add <symbol> <amount>
 dipcoin-cli position margin remove <symbol> <amount>
+
+# Same, but target a vault's position
+dipcoin-cli position margin add <symbol> <amount> --vault <vaultId>
+dipcoin-cli position margin remove <symbol> <amount> --vault <vaultId>
 ```
 
 The `--side` is the **closing side**: use `sell` for long positions, `buy` for short.
 
+> All on-chain margin / vault writes (`position margin add/remove`, `vault deposit/close/withdraw/claim/fill-withdrawals`) fetch a fresh signed price from `/api/perp-market-api/price/latest` and bundle a `price_feed::update_price_feed` PTB step before the actual call — required by the v6 oracle freshness check.
+
 #### vault
 
 On-chain vault operations (DipCoin vault contracts):
@@ -197,9 +212,9 @@ dipcoin-cli vault position <vaultId> --address <addr>  # Query another address
 dipcoin-cli vault deposit <vaultId> <amount>
 dipcoin-cli vault withdraw <vaultId> <shares>
 dipcoin-cli vault withdraw <vaultId> --all # Withdraw all shares
-dipcoin-cli vault fill <vaultId> <requestIDs...> [--markets <ids>]
-dipcoin-cli vault close <vaultId> [--markets <ids>]
-dipcoin-cli vault remove <vaultId>
+dipcoin-cli vault fill-withdrawals <vaultId> <requestIDs...>   # creator/operator only
+dipcoin-cli vault close <vaultId>
+dipcoin-cli vault remove <vaultId>                              # operator-only (normal creators get "unauthorized")
 dipcoin-cli vault claim <vaultId>
 dipcoin-cli vault set-trader <vaultId> <address>
 dipcoin-cli vault set-sub-trader <vaultId> <address> [--disable]

package/dist/cli.cjs

@@ -12973,7 +12973,11 @@ function formatNormalToWei(value, decimals = 18) {
  * @returns BigNumber instance
  */
 function formatNormalToWeiBN(value, decimals = 18) {
+    if (!value && value !== 0)
+        return new BigNumber__default["default"](0);
     const bn = new BigNumber__default["default"](value);
+    if (bn.isNaN())
+        return new BigNumber__default["default"](0);
     return bn.multipliedBy(new BigNumber__default["default"](10).pow(decimals));
 }
 /**
@@ -16369,6 +16373,8 @@ const API_ENDPOINTS = {
     FUNDING_SETTLEMENTS: "/api/perp-trade-api/history/funding-settlements",
     BALANCE_CHANGES: "/api/perp-trade-api/history/balance-changes",
     ORACLE: "/api/perp-market-api/oracle",
+    SIGNED_PRICE_LATEST: "/api/perp-market-api/price/latest",
+    KLINE_HISTORY: "/api/perp-market-api/kline/history",
     VAULTS_BY_CREATOR: "/api/perp-vault-api/public/vaults/by-creator",
     VAULTS_PUBLIC: "/api/perp-vault-api/public/vaults",
     // Points & Referral
@@ -16596,6 +16602,13 @@ function getPerpetualId(deployment, market) {
         throw new Error(`Deployment config missing Perpetual id for ${m}`);
     return id;
 }
+function getPriceFeedId(deployment) {
+    const id = deployment?.objects?.PriceFeed?.id;
+    if (!id) {
+        throw new Error("Deployment config missing PriceFeed id. Add objects.PriceFeed to the network's main_contract.json — required for v6+ on-chain margin/vault writes.");
+    }
+    return id;
+}
 function getPriceOracleObjectId(deployment, market) {
     const m = market?.toUpperCase() || "ETH-PERP";
     const id = deployment?.markets?.[m]?.Objects?.PriceInfoObject?.id;
@@ -16641,7 +16654,7 @@ function buildAddMarginTx(deployment, args, tx, gasBudget, sender) {
         t.setSender(sender);
     const packageId = getPackageId(deployment);
     t.moveCall({
-        target: `${packageId}::exchange::add_margin_v2`,
+        target: `${packageId}::exchange::add_margin_v3`,
         arguments: [
             t.object(getProtocolConfigId(deployment)),
             t.object(CLOCK_OBJECT_ID),
@@ -16649,7 +16662,7 @@ function buildAddMarginTx(deployment, args, tx, gasBudget, sender) {
             t.object(getBankId(deployment)),
             t.object(args.subAccountsMapID || getSubAccountsId(deployment)),
             t.object(getTxIndexerId(deployment)),
-            t.object(getPriceOracleObjectId(deployment, args.market)),
+            t.object(getPriceFeedId(deployment)),
             t.pure.address(args.account || sender || ""),
             t.pure.u128(args.amount.toString()),
         ],
@@ -16665,7 +16678,7 @@ function buildRemoveMarginTx(deployment, args, tx, gasBudget, sender) {
         t.setSender(sender);
     const packageId = getPackageId(deployment);
     t.moveCall({
-        target: `${packageId}::exchange::remove_margin_v2`,
+        target: `${packageId}::exchange::remove_margin_v3`,
         arguments: [
             t.object(getProtocolConfigId(deployment)),
             t.object(CLOCK_OBJECT_ID),
@@ -16673,7 +16686,7 @@ function buildRemoveMarginTx(deployment, args, tx, gasBudget, sender) {
             t.object(getBankId(deployment)),
             t.object(args.subAccountsMapID || getSubAccountsId(deployment)),
             t.object(getTxIndexerId(deployment)),
-            t.object(getPriceOracleObjectId(deployment, args.market)),
+            t.object(getPriceFeedId(deployment)),
             t.pure.address(args.account || sender || ""),
             t.pure.u128(args.amount.toString()),
         ],
@@ -16744,17 +16757,6 @@ function buildSetOraclePriceTx(deployment, args, tx, gasBudget, sender) {
     });
     return t;
 }
-function buildBatchSetOraclePriceTx(deployment, args, tx, gasBudget, sender) {
-    let t = tx || new transactions.Transaction();
-    for (const priceArgs of args.prices) {
-        t = buildSetOraclePriceTx(deployment, priceArgs, t, undefined, undefined);
-    }
-    if (gasBudget)
-        t.setGasBudget(gasBudget);
-    if (sender)
-        t.setSender(sender);
-    return t;
-}
 
 // Copyright (c) 2025 Dipcoin LLC
 async function executeTxBlock(suiClient, tx, signer) {
@@ -18562,6 +18564,77 @@ class DipCoinPerpSDK {
             return { status: false, error: formatError(error) };
         }
     }
+    /**
+     * Fetch kline (candlestick) history for a market.
+     *
+     * @param params.symbol    Trading pair (e.g. "BTC-PERP")
+     * @param params.interval  Bar interval (e.g. "1m" / "5m" / "1h" / "1d")
+     * @param params.from      Inclusive start timestamp (Unix seconds)
+     * @param params.to        Exclusive end timestamp (Unix seconds)
+     * @param params.countback Optional cap on returned bars (most recent first)
+     */
+    async getKlineHistory(params) {
+        try {
+            if (!params?.symbol)
+                return { status: false, error: "symbol is required" };
+            if (!params?.interval)
+                return { status: false, error: "interval is required" };
+            // Server requires both startTime and endTime in unix seconds.
+            const nowSec = Math.floor(Date.now() / 1000);
+            const startTime = params.from ?? nowSec - 86400;
+            const endTime = params.to ?? nowSec;
+            const response = await this.httpClient.get(API_ENDPOINTS.KLINE_HISTORY, {
+                params: {
+                    symbol: params.symbol,
+                    interval: params.interval,
+                    startTime,
+                    endTime,
+                    ...(params.countback !== undefined ? { countback: params.countback } : {}),
+                },
+            });
+            if (response.code !== 200) {
+                return { status: false, error: response.message || `code ${response.code}` };
+            }
+            const raw = Array.isArray(response.data)
+                ? response.data
+                : Array.isArray(response.data?.data)
+                    ? response.data.data
+                    : [];
+            const weiToNormal = (v) => {
+                if (v === undefined || v === null || v === "")
+                    return "0";
+                const bn = new BigNumber__default["default"](String(v));
+                if (!bn.isFinite() || bn.isZero())
+                    return "0";
+                return bn.dividedBy(new BigNumber__default["default"](10).pow(18)).toString();
+            };
+            const bars = raw.map((row) => {
+                if (Array.isArray(row)) {
+                    const [time, open, high, low, close, volume] = row;
+                    return {
+                        time: Number(time ?? 0),
+                        open: weiToNormal(open),
+                        high: weiToNormal(high),
+                        low: weiToNormal(low),
+                        close: weiToNormal(close),
+                        volume: weiToNormal(volume),
+                    };
+                }
+                return {
+                    time: Number(row.time ?? row.timestamp ?? 0),
+                    open: weiToNormal(row.open),
+                    high: weiToNormal(row.high),
+                    low: weiToNormal(row.low),
+                    close: weiToNormal(row.close),
+                    volume: weiToNormal(row.volume ?? row.vol),
+                };
+            });
+            return { status: true, data: bars };
+        }
+        catch (error) {
+            return { status: false, error: formatError(error) };
+        }
+    }
     /**
      * Add isolated margin to an existing position (on-chain)
      * @param params Margin adjustment parameters
@@ -18624,10 +18697,14 @@ class DipCoinPerpSDK {
     }
     async buildMarginTransaction(params, action) {
         const payload = this.buildMarginCallArgs(params, action);
-        const updatePriceTx = payload.market
-            ? await this.buildUpdatePriceTransaction(payload.market)
-            : undefined;
-        const baseTx = updatePriceTx || new transactions.Transaction();
+        // v6+ requires PriceFeed to be fresh (~60s) before the margin call. Operator updates
+        // are only hourly so we always fetch + prepend our own update_price_feed step.
+        const sym = payload.market || params.symbol;
+        if (!sym)
+            throw new Error("symbol/market required to refresh PriceFeed before margin op");
+        const feeds = await this.fetchSignedPriceFeeds([sym]);
+        const baseTx = new transactions.Transaction();
+        this.appendPriceFeedUpdates(baseTx, Array.from(feeds.values()));
         if (action === "add") {
             return buildAddMarginTx(this.deploymentConfig, payload, baseTx, params.gasBudget);
         }
@@ -18913,45 +18990,101 @@ class DipCoinPerpSDK {
             throw new Error(`Deployment config missing PriceInfoObject id for ${symbol}`);
         return id;
     }
-    async buildVaultNavTransaction(vaultID, markets, tx) {
+    getPriceFeedId() {
+        const id = this.deploymentConfig?.objects?.PriceFeed?.id;
+        if (!id) {
+            throw new Error("Deployment config missing PriceFeed id. Add objects.PriceFeed to the network's main_contract.json — required for v6+ vault/margin writes.");
+        }
+        return id;
+    }
+    /**
+     * Fetch signed price update bytes for the given markets from the DipCoin pricing service.
+     * Each entry's payload/signature/publicKey is consumed by
+     * `<pkg>::price_feed::update_price_feed(PriceFeed, Clock, payload, signature, publicKey)`.
+     *
+     * The on-chain v6 contract requires the PriceFeed entry for a perp to be fresh (~60s)
+     * for any margin/vault NAV write. The CLI prepends one update_price_feed call per
+     * perp involved in the tx before the actual margin/vault call.
+     */
+    async fetchSignedPriceFeeds(symbols) {
+        const out = new Map();
+        if (symbols.length === 0)
+            return out;
+        const qs = symbols.map((s) => `symbols=${encodeURIComponent(s)}`).join("&");
+        const resp = await this.httpClient.get(`${API_ENDPOINTS.SIGNED_PRICE_LATEST}?${qs}`);
+        if (resp.code !== 200 || !resp.data) {
+            throw new Error(`Failed to fetch signed price feed for [${symbols.join(",")}]: ${resp.message || `code ${resp.code}`}`);
+        }
+        const d = resp.data;
+        const b64 = (s) => Uint8Array.from(Buffer.from(s, "base64"));
+        if (!d.payload || !d.signature || !d.publicKey) {
+            throw new Error("Signed price feed response missing payload/signature/publicKey");
+        }
+        const entry = { payload: b64(d.payload), signature: b64(d.signature), publicKey: b64(d.publicKey) };
+        // API returns a single bundle covering all requested symbols' prices in priceList,
+        // but only one (payload, signature, publicKey) tuple. Map every requested symbol to it.
+        for (const sym of symbols)
+            out.set(sym, entry);
+        return out;
+    }
+    /**
+     * Build a `price_feed::update_price_feed` PTB command for each provided signed feed
+     * entry and append to the given transaction.
+     */
+    appendPriceFeedUpdates(tx, feeds) {
+        const pkg = this.getPackageId();
+        const pfId = this.getPriceFeedId();
+        for (const f of feeds) {
+            tx.moveCall({
+                target: `${pkg}::price_feed::update_price_feed`,
+                arguments: [
+                    tx.object(pfId),
+                    tx.object("0x6"),
+                    tx.pure.vector("u8", Array.from(f.payload)),
+                    tx.pure.vector("u8", Array.from(f.signature)),
+                    tx.pure.vector("u8", Array.from(f.publicKey)),
+                ],
+                typeArguments: [],
+            });
+        }
+    }
+    getPackageId() {
+        const pkgs = this.deploymentConfig?.packages;
+        if (!pkgs || !pkgs.length)
+            throw new Error("Deployment config missing packages array");
+        return pkgs[pkgs.length - 1];
+    }
+    async getOnChainPerpetualIds() {
+        const pcId = this.getDeploymentProtocolConfigId();
+        const df = await this.suiClient.getDynamicFieldObject({
+            parentId: pcId,
+            name: {
+                type: "vector<u8>",
+                value: Array.from(Buffer.from("perpetual_registry", "utf8")),
+            },
+        });
+        const content = df.data?.content;
+        const contents = content?.fields?.value?.fields?.perpetuals?.fields?.contents;
+        if (!Array.isArray(contents)) {
+            throw new Error("Could not read perpetual_registry from on-chain ProtocolConfig. Vault NAV requires the full list of perpetuals registered in the protocol.");
+        }
+        return contents;
+    }
+    async buildVaultNavTransaction(vaultID, _markets, tx) {
         const t = tx || new transactions.Transaction();
         const vaultPkg = this.getVaultPackageId();
         const currencyType = this.getCurrencyType();
-        const symbols = markets && markets.length > 0 ? markets : this.getMarketSymbols();
-        if (this.options.network === "mainnet") {
-            // On mainnet, use Pyth to fetch fresh price VAAs and update on-chain oracles
-            this.ensurePythClients();
-            if (this.priceServiceConnection && this.pythClient) {
-                const priceIds = [];
-                for (const sym of symbols) {
-                    const feedId = await this.resolvePriceFeedId(sym);
-                    if (feedId)
-                        priceIds.push(feedId);
-                }
-                if (priceIds.length > 0) {
-                    const priceUpdateData = await this.priceServiceConnection.getPriceFeedsUpdateData(priceIds);
-                    await this.pythClient.updatePriceFeeds(t, priceUpdateData, priceIds);
-                }
-            }
-        }
-        else {
-            // On testnet, prepend price oracle updates so PriceInfoObjects are fresh
-            const prices = [];
-            for (const sym of symbols) {
-                try {
-                    const oraclePrice = await getOraclePrice(this.suiClient, this.deploymentConfig, sym);
-                    if (oraclePrice !== undefined && oraclePrice !== null) {
-                        prices.push({ price: Number(oraclePrice), market: sym });
-                    }
-                }
-                catch {
-                    // skip symbols where oracle price is unavailable
-                }
-            }
-            if (prices.length > 0) {
-                buildBatchSetOraclePriceTx(this.deploymentConfig, { prices }, t);
-            }
-        }
+        // v6+: PriceFeed must be fresh for every perp whose value compute_perpetual_position_value_v2
+        // will touch. Refresh ALL markets first by fetching one combined signed bundle and prepending
+        // a single update_price_feed step. Then iterate the on-chain perpetual_registry (which is
+        // what new_vault_nav populates, and is_nav_filled requires every entry to be computed).
+        const priceFeedId = this.getPriceFeedId();
+        const allSymbols = this.getMarketSymbols();
+        const feeds = await this.fetchSignedPriceFeeds(allSymbols);
+        // Dedup the bundle entries (the API returns one tuple covering all requested symbols).
+        const uniqFeeds = Array.from(new Map(Array.from(feeds.values()).map((f) => [Buffer.from(f.payload).toString("hex"), f])).values());
+        this.appendPriceFeedUpdates(t, uniqFeeds);
+        const perpetualIds = await this.getOnChainPerpetualIds();
         const [nav] = t.moveCall({
             target: `${vaultPkg}::vault::new_vault_nav`,
             arguments: [
@@ -18962,12 +19095,10 @@ class DipCoinPerpSDK {
             ],
             typeArguments: [currencyType],
         });
-        for (const sym of symbols) {
-            const perpId = this.getVaultPerpetualId(sym);
-            const priceInfoId = this.getVaultPriceInfoObjectId(sym);
+        for (const perpId of perpetualIds) {
             t.moveCall({
-                target: `${vaultPkg}::vault::compute_perpetual_position_value`,
-                arguments: [nav, t.object("0x6"), t.object(perpId), t.object(priceInfoId)],
+                target: `${vaultPkg}::vault::compute_perpetual_position_value_v2`,
+                arguments: [nav, t.object("0x6"), t.object(perpId), t.object(priceFeedId)],
                 typeArguments: [],
             });
         }
@@ -19833,6 +19964,34 @@ function registerTradeCommands(program) {
         .argument("<symbol>", "Trading pair (e.g. BTC or BTC-PERP)")
         .argument("<amount>", "USDC margin amount (e.g. 100 or 100USDC)")
         .argument("<leverage>", "Leverage multiplier (e.g. 10 or 10x)")).action((symbol, amount, leverage, opts) => placeOrder(program, OrderSide.SELL, symbol, amount, leverage, opts));
+    trade
+        .command("leverage")
+        .description("Adjust default leverage for a market (e.g. trade leverage BTC 10)")
+        .argument("<symbol>", "Trading pair (e.g. BTC or BTC-PERP)")
+        .argument("<leverage>", "Leverage multiplier (e.g. 10 or 10x)")
+        .action(async (symbol, leverage) => {
+        try {
+            symbol = normalizeSymbol(symbol);
+            const lev = Number(String(leverage).replace(/x$/i, ""));
+            if (!Number.isFinite(lev) || lev <= 0)
+                return handleError(`Invalid leverage: ${leverage}`);
+            const sdk = getSDK();
+            // Only ISOLATED margin is supported by the backend today.
+            const result = await sdk.adjustLeverage({
+                symbol,
+                leverage: lev,
+                marginType: "ISOLATED",
+            });
+            if (!result.status)
+                return handleError(result.error);
+            if (isJson(program))
+                return printJson(result.data);
+            console.log(`Leverage for ${symbol} set to ${lev}x (ISOLATED).`);
+        }
+        catch (e) {
+            handleError(e);
+        }
+    });
     trade
         .command("cancel")
         .description("Cancel orders by hash")
@@ -19996,11 +20155,16 @@ function registerPositionCommands(program) {
         .description("Add margin to position")
         .argument("<symbol>", "Trading pair")
         .argument("<amount>", "Amount in USDC")
-        .action(async (symbol, amount) => {
+        .option("--vault <address>", "Target a vault's position (vault id) instead of personal account")
+        .action(async (symbol, amount, opts) => {
         try {
             const sdk = getSDK();
             symbol = normalizeSymbol(symbol);
-            const tx = await sdk.addMargin({ symbol, amount: parseAmount(amount) });
+            const tx = await sdk.addMargin({
+                symbol,
+                amount: parseAmount(amount),
+                accountAddress: opts.vault,
+            });
             if (isJson(program))
                 return printJson({ digest: tx?.digest, status: "ok" });
             console.log(`Added ${amount} margin to ${symbol}. Tx: ${tx?.digest || JSON.stringify(tx)}`);
@@ -20014,11 +20178,16 @@ function registerPositionCommands(program) {
         .description("Remove margin from position")
         .argument("<symbol>", "Trading pair")
         .argument("<amount>", "Amount in USDC")
-        .action(async (symbol, amount) => {
+        .option("--vault <address>", "Target a vault's position (vault id) instead of personal account")
+        .action(async (symbol, amount, opts) => {
         try {
             const sdk = getSDK();
             symbol = normalizeSymbol(symbol);
-            const tx = await sdk.removeMargin({ symbol, amount: parseAmount(amount) });
+            const tx = await sdk.removeMargin({
+                symbol,
+                amount: parseAmount(amount),
+                accountAddress: opts.vault,
+            });
             if (isJson(program))
                 return printJson({ digest: tx?.digest, status: "ok" });
             console.log(`Removed ${amount} margin from ${symbol}. Tx: ${tx?.digest || JSON.stringify(tx)}`);
@@ -20130,6 +20299,48 @@ function registerMarketCommands(program) {
             handleError(e);
         }
     });
+    market
+        .command("kline")
+        .description("Get kline (candlestick) history for a symbol")
+        .argument("<symbol>", "Trading pair")
+        .option("--interval <i>", "Bar interval: 1m / 5m / 15m / 30m / 1h / 4h / 1d / 1w (default: 1h)", "1h")
+        .option("--from <ts>", "Start unix timestamp in seconds (default: 24h ago)")
+        .option("--to <ts>", "End unix timestamp in seconds (default: now)")
+        .option("--count <n>", "Cap on number of bars returned (most recent first)")
+        .action(async (symbol, opts) => {
+        try {
+            symbol = normalizeSymbol(symbol);
+            const now = Math.floor(Date.now() / 1000);
+            const from = opts.from !== undefined ? Number(opts.from) : now - 86400;
+            const to = opts.to !== undefined ? Number(opts.to) : now;
+            const countback = opts.count !== undefined ? Number(opts.count) : undefined;
+            const sdk = getSDK();
+            const result = await sdk.getKlineHistory({
+                symbol,
+                interval: String(opts.interval),
+                from,
+                to,
+                countback,
+            });
+            if (!result.status || !result.data)
+                return handleError(result.error);
+            if (isJson(program))
+                return printJson(result.data);
+            if (!result.data.length)
+                return console.log("No bars.");
+            printTable(["Time (UTC)", "Open", "High", "Low", "Close", "Volume"], result.data.map((b) => [
+                new Date(b.time * 1000).toISOString().replace("T", " ").slice(0, 16),
+                b.open,
+                b.high,
+                b.low,
+                b.close,
+                b.volume,
+            ]));
+        }
+        catch (e) {
+            handleError(e);
+        }
+    });
 }
 
 function registerHistoryCommands(program) {
@@ -20558,11 +20769,12 @@ function registerVaultCommands(program) {
     });
     // === vault fill ===
     vault
-        .command("fill")
-        .description("Fill pending withdrawal requests (e.g. vault fill <vaultId> <requestIDs...>)")
+        .command("fill-withdrawals")
+        .alias("fill")
+        .description("Fill pending withdrawal requests (creator/operator only) — e.g. vault fill-withdrawals <vaultId> <requestIDs...>")
         .argument("<vaultId>", "Vault object ID")
         .argument("<requestIDs...>", "Withdrawal request object IDs")
-        .option("--markets <ids>", "Comma-separated market PerpetualIDs for share price update")
+        .option("--markets <ids>", "Comma-separated market PerpetualIDs (deprecated; NAV now uses on-chain registry)")
         .action(async (vaultId, requestIDs, opts) => {
         try {
             const sdk = getSDK();