dipcoin-cli 1.3.0 → 1.3.3

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,29 @@ 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)
+# Close positions — CLI figures out side & qty
+dipcoin-cli position close BTC                  # close 100% of BTC position
+dipcoin-cli position close BTC --percent 50     # close half
+dipcoin-cli position close-all                  # close every open position
+dipcoin-cli position close-all --percent 50     # halve every open position
+
+# Manual form is still supported (specify exact qty yourself):
+dipcoin-cli trade sell BTC 0 10x --qty 0.01 --reduce-only   # close 0.01 of a long
+dipcoin-cli trade buy ETH 0 5x  --qty 1     --reduce-only   # close 1 of a short
+
+# 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 +222,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
@@ -18558,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
@@ -18620,9 +18697,14 @@ class DipCoinPerpSDK {
     }
     async buildMarginTransaction(params, action) {
         const payload = this.buildMarginCallArgs(params, action);
-        // v6+ uses add_margin_v3/remove_margin_v3 which read &PriceFeed (a shared object
-        // maintained off-band by an operator). No Pyth update is needed on the user-side tx.
+        // 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);
         }
@@ -18915,6 +18997,63 @@ class DipCoinPerpSDK {
         }
         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({
@@ -18935,12 +19074,16 @@ class DipCoinPerpSDK {
         const t = tx || new transactions.Transaction();
         const vaultPkg = this.getVaultPackageId();
         const currencyType = this.getCurrencyType();
-        // v6+: PriceFeed is a single shared object maintained by an operator off-band.
-        // new_vault_nav populates `perpetuals` from ProtocolConfig.perpetual_registry, and
-        // is_nav_filled requires EVERY registered perpetual to have a position value entry.
-        // So we must compute against the on-chain registry, not the local deployment.markets
-        // list (which can drift behind chain additions).
+        // 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`,
@@ -19821,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")
@@ -19921,6 +20092,134 @@ function registerPositionCommands(program) {
             handleError(e);
         }
     });
+    // Helper: align a human-readable quantity to the market's step size.
+    async function alignToStepSize(sdk, symbol, qty) {
+        let stepSize = 0.001;
+        try {
+            const pairResult = await sdk.getTradingPairs();
+            if (pairResult.status && pairResult.data) {
+                const pair = pairResult.data.find((p) => p.symbol === symbol);
+                const raw = pair?.stepSize ?? pair?.minTradeQty;
+                if (raw) {
+                    const parsed = parseFloat(raw);
+                    if (parsed > 0)
+                        stepSize = parsed > 1e10 ? parsed / 1e18 : parsed;
+                }
+            }
+        }
+        catch {
+            // fall through with default stepSize
+        }
+        const stepped = Math.floor(qty / stepSize) * stepSize;
+        const decimals = stepSize < 1 ? Math.ceil(-Math.log10(stepSize)) : 0;
+        return parseFloat(stepped.toFixed(decimals));
+    }
+    // Helper: close one position with a reduce-only market order. Returns the API response.
+    async function closeOnePosition(sdk, pos, percent, vault) {
+        const symbol = pos.symbol;
+        const sideStr = String(pos.side).toUpperCase();
+        const closingSide = sideStr === "BUY" ? OrderSide.SELL : OrderSide.BUY;
+        const totalQtyHuman = Number(pos.quantity) / 1e18;
+        const wanted = totalQtyHuman * (percent / 100);
+        const aligned = await alignToStepSize(sdk, symbol, wanted);
+        if (aligned <= 0) {
+            return {
+                ok: false,
+                message: `Closing ${percent}% of ${totalQtyHuman} ${symbol} would round to 0 at market step size — try a larger percentage.`,
+            };
+        }
+        const perpId = await sdk.getPerpetualID(symbol);
+        if (!perpId)
+            return { ok: false, message: `PerpetualID not found for ${symbol}` };
+        const leverageHuman = String(Number(pos.leverage) / 1e18);
+        const params = {
+            symbol,
+            market: perpId,
+            side: closingSide,
+            orderType: OrderType.MARKET,
+            quantity: String(aligned),
+            leverage: leverageHuman,
+            reduceOnly: true,
+        };
+        if (vault)
+            params.creator = vault;
+        const result = await sdk.placeOrder(params);
+        if (!result.status)
+            return { ok: false, message: result.error || "placeOrder failed" };
+        return {
+            ok: true,
+            message: `Closed ${aligned} ${symbol} (${closingSide} reduce-only).`,
+            data: result.data,
+        };
+    }
+    position
+        .command("close")
+        .description("Close a position with a reduce-only market order (default: 100%)")
+        .argument("<symbol>", "Trading pair (e.g. BTC or BTC-PERP)")
+        .option("--percent <n>", "Percent of position to close (1-100, default: 100)", "100")
+        .option("--vault <address>", "Target a vault's position instead of personal")
+        .action(async (symbol, opts) => {
+        try {
+            symbol = normalizeSymbol(symbol);
+            const percent = Number(opts.percent);
+            if (!Number.isFinite(percent) || percent <= 0 || percent > 100) {
+                return handleError(`--percent must be in (0, 100], got ${opts.percent}`);
+            }
+            const sdk = getSDK();
+            const parentAddress = opts.vault || sdk.address;
+            const result = await sdk.getPositions({ parentAddress, symbol });
+            if (!result.status)
+                return handleError(result.error);
+            const pos = (result.data || []).find((p) => p.symbol === symbol);
+            if (!pos)
+                return handleError(`No open position for ${symbol}.`);
+            const r = await closeOnePosition(sdk, pos, percent, opts.vault);
+            if (!r.ok)
+                return handleError(r.message);
+            if (isJson(program))
+                return printJson(r.data);
+            console.log(r.message);
+        }
+        catch (e) {
+            handleError(e);
+        }
+    });
+    position
+        .command("close-all")
+        .description("Close every open position with reduce-only market orders")
+        .option("--percent <n>", "Percent of each position to close (1-100, default: 100)", "100")
+        .option("--vault <address>", "Target vault positions instead of personal")
+        .action(async (opts) => {
+        try {
+            const percent = Number(opts.percent);
+            if (!Number.isFinite(percent) || percent <= 0 || percent > 100) {
+                return handleError(`--percent must be in (0, 100], got ${opts.percent}`);
+            }
+            const sdk = getSDK();
+            const parentAddress = opts.vault || sdk.address;
+            const result = await sdk.getPositions({ parentAddress });
+            if (!result.status)
+                return handleError(result.error);
+            const positions = result.data || [];
+            if (!positions.length) {
+                if (isJson(program))
+                    return printJson({ closed: 0, results: [] });
+                return console.log("No open positions to close.");
+            }
+            const results = [];
+            for (const pos of positions) {
+                const r = await closeOnePosition(sdk, pos, percent, opts.vault);
+                results.push({ symbol: pos.symbol, ok: r.ok, message: r.message });
+                if (!isJson(program))
+                    console.log(`  ${pos.symbol}: ${r.ok ? "OK" : "FAILED"} — ${r.message}`);
+            }
+            if (isJson(program))
+                printJson({ closed: results.filter((r) => r.ok).length, results });
+        }
+        catch (e) {
+            handleError(e);
+        }
+    });
     position
         .command("tpsl")
         .description("Place TP/SL orders on a position")
@@ -20128,6 +20427,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) {
@@ -20556,11 +20897,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();