dipcoin-cli 1.3.1 → 1.3.3

package/README.md

@@ -181,6 +181,16 @@ 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
 
+# 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>

package/dist/cli.cjs

@@ -20092,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")