dipcoin-cli 1.3.5 → 1.3.6

package/README.md

@@ -181,6 +181,10 @@ 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
 
+# Set or edit TP/SL on a vault position. Existing plan IDs are discovered automatically.
+dipcoin-cli position tpsl BTC --side sell --quantity 0.01 --leverage 10 \
+  --vault <vaultId> --tp-trigger 105000 --sl-trigger 90000
+
 # 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

package/dist/cli.cjs

@@ -17700,7 +17700,8 @@ class DipCoinPerpSDK {
             }
             // Use sub-account keypair for signing if available
             const signingKeypair = this.subKeypair || this.keypair;
-            const { symbol, market, side, isLong, leverage, quantity, reduceOnly = true, postOnly = false, orderbookOnly = true, ioc = false, tp, sl, } = params;
+            const { symbol, market, creator, side, isLong, leverage, quantity, reduceOnly = true, postOnly = false, orderbookOnly = true, ioc = false, tp, sl, } = params;
+            const orderCreator = creator || this.walletAddress;
             if (!this.isPositiveNumber(quantity)) {
                 return {
                     status: false,
@@ -17724,7 +17725,7 @@ class DipCoinPerpSDK {
                 symbol,
                 side,
                 leverage: leverageWei,
-                creator: this.walletAddress,
+                creator: orderCreator,
             };
             const sendPlanCloseRequest = async (payload) => {
                 let response = await this.httpClient.post(API_ENDPOINTS.PLAN_CLOSE_ORDER, payload);
@@ -17754,7 +17755,7 @@ class DipCoinPerpSDK {
                     : new BigNumber__default["default"](0);
                 const tpOrder = {
                     market,
-                    creator: this.walletAddress,
+                    creator: orderCreator,
                     isLong: !isLong,
                     reduceOnly,
                     postOnly,
@@ -17799,7 +17800,7 @@ class DipCoinPerpSDK {
                     : new BigNumber__default["default"](0);
                 const slOrder = {
                     market,
-                    creator: this.walletAddress,
+                    creator: orderCreator,
                     isLong: !isLong,
                     reduceOnly,
                     postOnly,
@@ -17871,7 +17872,7 @@ class DipCoinPerpSDK {
     /**
      * Get TP/SL orders for a position
      */
-    async getPositionTpSl(positionId, tpslType = "normal") {
+    async getPositionTpSl(positionId, tpslType = "normal", parentAddress) {
         try {
             const authResult = await this.authenticate();
             if (!authResult.status) {
@@ -17883,6 +17884,7 @@ class DipCoinPerpSDK {
             const params = {
                 positionId,
                 tpslType,
+                ...(parentAddress ? { parentAddress } : {}),
             };
             let response = await this.httpClient.get(API_ENDPOINTS.GET_POSITION_TPSL, { params });
             if (response.code === 1000) {
@@ -20740,6 +20742,9 @@ function registerPositionCommands(program) {
         .option("--sl-trigger <price>", "SL trigger price")
         .option("--sl-type <type>", "SL order type: market or limit", "market")
         .option("--sl-price <price>", "SL order price (for limit)")
+        .option("--vault <address>", "Target a vault position (vault object ID)")
+        .option("--tp-plan-id <id>", "Existing TP plan ID to edit")
+        .option("--sl-plan-id <id>", "Existing SL plan ID to edit")
         .action(async (symbol, opts) => {
         try {
             const sdk = getSDK();
@@ -20747,11 +20752,94 @@ function registerPositionCommands(program) {
             const perpId = await sdk.getPerpetualID(symbol);
             if (!perpId)
                 return handleError(`PerpetualID not found for ${symbol}`);
-            const side = opts.side.toUpperCase() === "BUY" ? OrderSide.BUY : OrderSide.SELL;
+            const sideInput = String(opts.side).toUpperCase();
+            if (sideInput !== OrderSide.BUY && sideInput !== OrderSide.SELL) {
+                return handleError(`--side must be buy or sell, got ${opts.side}`);
+            }
+            const side = sideInput;
             const isLong = side === OrderSide.SELL;
+            if (!opts.tpTrigger && !opts.slTrigger) {
+                return handleError("At least one of --tp-trigger or --sl-trigger is required.");
+            }
+            if (opts.tpPlanId && !opts.tpTrigger) {
+                return handleError("--tp-plan-id requires --tp-trigger.");
+            }
+            if (opts.slPlanId && !opts.slTrigger) {
+                return handleError("--sl-plan-id requires --sl-trigger.");
+            }
+            let tpPlanId = opts.tpPlanId;
+            let slPlanId = opts.slPlanId;
+            const shouldFindTpPlan = Boolean(opts.tpTrigger && !tpPlanId);
+            const shouldFindSlPlan = Boolean(opts.slTrigger && !slPlanId);
+            const parentAddress = opts.vault || sdk.address;
+            const positionsResult = await sdk.getPositions({ parentAddress, symbol });
+            if (!positionsResult.status) {
+                return handleError(positionsResult.error || "Failed to fetch position");
+            }
+            const matchingPositions = (positionsResult.data || []).filter((position) => position.symbol === symbol);
+            if (matchingPositions.length !== 1) {
+                return handleError(matchingPositions.length === 0
+                    ? `No open position for ${symbol}.`
+                    : `Multiple positions found for ${symbol}; cannot choose one safely.`);
+            }
+            const activePosition = matchingPositions[0];
+            const positionSide = String(activePosition.side).toUpperCase();
+            const expectedClosingSide = positionSide === "BUY" || positionSide === "LONG"
+                ? OrderSide.SELL
+                : positionSide === "SELL" || positionSide === "SHORT"
+                    ? OrderSide.BUY
+                    : undefined;
+            if (!expectedClosingSide) {
+                return handleError(`Unsupported position side: ${activePosition.side}`);
+            }
+            if (side !== expectedClosingSide) {
+                return handleError(`--side must be ${expectedClosingSide.toLowerCase()} to close a ${positionSide} position.`);
+            }
+            const requestedQuantity = new BigNumber__default["default"](opts.quantity);
+            const positionQuantity = new BigNumber__default["default"](activePosition.quantity).shiftedBy(-18);
+            if (!requestedQuantity.isFinite() ||
+                requestedQuantity.lte(0) ||
+                requestedQuantity.gt(positionQuantity)) {
+                return handleError(`--quantity must be greater than 0 and no more than the position quantity (${positionQuantity.toFixed()}).`);
+            }
+            const requestedLeverage = new BigNumber__default["default"](opts.leverage);
+            const positionLeverage = new BigNumber__default["default"](activePosition.leverage).shiftedBy(-18);
+            if (!requestedLeverage.isFinite() || !requestedLeverage.eq(positionLeverage)) {
+                return handleError(`--leverage must match the position leverage (${positionLeverage.toFixed()}).`);
+            }
+            // Editing a plan requires its existing ID. Resolve it automatically for the
+            // position-wide TP/SL pair so repeating this command updates instead of duplicates.
+            if (shouldFindTpPlan || shouldFindSlPlan) {
+                const positionId = activePosition.id ?? activePosition.positionId;
+                if (positionId === undefined || positionId === null) {
+                    return handleError(`Position ID missing for ${symbol}.`);
+                }
+                const plansResult = await sdk.getPositionTpSl(positionId, "position", opts.vault);
+                if (!plansResult.status) {
+                    return handleError(plansResult.error || "Failed to fetch existing TP/SL orders");
+                }
+                const findExistingPlanId = (planOrderType) => {
+                    const matches = (plansResult.data || []).filter((order) => String(order.planOrderType).toLowerCase() === planOrderType.toLowerCase());
+                    if (matches.length > 1) {
+                        throw new Error(`Multiple ${planOrderType} plans found; use --${planOrderType === "takeProfit" ? "tp" : "sl"}-plan-id to choose one.`);
+                    }
+                    if (!matches.length)
+                        return undefined;
+                    const planId = planOrderType === "takeProfit" ? matches[0].tpPlanId : matches[0].slPlanId;
+                    if (planId === undefined || planId === null) {
+                        throw new Error(`${planOrderType} plan is missing its editable plan ID.`);
+                    }
+                    return planId;
+                };
+                if (shouldFindTpPlan)
+                    tpPlanId = findExistingPlanId("takeProfit");
+                if (shouldFindSlPlan)
+                    slPlanId = findExistingPlanId("stopLoss");
+            }
             const params = {
                 symbol,
                 market: perpId,
+                ...(opts.vault ? { creator: opts.vault } : {}),
                 side,
                 isLong,
                 quantity: opts.quantity,
@@ -20762,6 +20850,7 @@ function registerPositionCommands(program) {
                     triggerPrice: opts.tpTrigger,
                     orderType: opts.tpType?.toUpperCase() === "LIMIT" ? OrderType.LIMIT : OrderType.MARKET,
                     ...(opts.tpPrice ? { orderPrice: opts.tpPrice } : {}),
+                    ...(tpPlanId !== undefined ? { planId: tpPlanId } : {}),
                     tpslType: "position",
                 };
             }
@@ -20770,6 +20859,7 @@ function registerPositionCommands(program) {
                     triggerPrice: opts.slTrigger,
                     orderType: opts.slType?.toUpperCase() === "LIMIT" ? OrderType.LIMIT : OrderType.MARKET,
                     ...(opts.slPrice ? { orderPrice: opts.slPrice } : {}),
+                    ...(slPlanId !== undefined ? { planId: slPlanId } : {}),
                     tpslType: "position",
                 };
             }