dipcoin-cli 1.3.4 → 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

@@ -12921,8 +12921,8 @@ async function signMessage(keypair, messageBytes) {
  */
 function buildSignature(signature, isKeyPair = false) {
     const signatureData = cryptography.parseSerializedSignature(signature);
-    let signatureHex = buffer.Buffer.from(signatureData.signature).toString("hex");
-    let publicKey = buffer.Buffer.from(signatureData.publicKey).toString("base64");
+    const signatureHex = buffer.Buffer.from(signatureData.signature).toString("hex");
+    const publicKey = buffer.Buffer.from(signatureData.publicKey).toString("base64");
     let flag = SignerTypes.KP_SECP256;
     if (signatureData.signatureScheme === "Secp256k1" ||
         signatureData.signatureScheme === "Secp256r1") {
@@ -13006,13 +13006,11 @@ function getModuleDir() {
             return path__default["default"].dirname(__filename);
         }
     }
-    catch (e) {
+    catch {
         // Fall through to CommonJS
     }
     // CommonJS: use __dirname (will be available after compilation)
-    // @ts-ignore - __dirname may not be defined in ESM context
     if (typeof __dirname !== "undefined") {
-        // @ts-ignore
         return __dirname;
     }
     // Fallback to process.cwd()
@@ -16457,8 +16455,12 @@ class HttpClient {
             const proc = child_process.spawn("curl", args);
             let stdout = "";
             let stderr = "";
-            proc.stdout.on("data", (chunk) => { stdout += chunk; });
-            proc.stderr.on("data", (chunk) => { stderr += chunk; });
+            proc.stdout.on("data", (chunk) => {
+                stdout += chunk;
+            });
+            proc.stderr.on("data", (chunk) => {
+                stderr += chunk;
+            });
             proc.on("close", (code) => {
                 if (!stdout) {
                     return reject(new Error(stderr || `curl exited with code ${code}`));
@@ -16806,17 +16808,87 @@ function buildSetOraclePriceTx(deployment, args, tx, gasBudget, sender) {
     return t;
 }
 
+// Copyright (c) 2025 Dipcoin LLC
+// SPDX-License-Identifier: Apache-2.0
+const SUI_COIN_TYPE = "0x2::sui::SUI";
+const STALE_GAS_RETRY_DELAY_MS = 1000;
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function getErrorMessage(error) {
+    if (error instanceof Error)
+        return error.message;
+    return String(error);
+}
+function isStaleObjectVersionError(error) {
+    const message = getErrorMessage(error);
+    return (message.includes("Transaction needs to be rebuilt") ||
+        message.includes("unavailable for consumption") ||
+        message.includes("current version:"));
+}
+async function getFreshGasObjectRef(suiClient, owner) {
+    const coins = [];
+    let cursor;
+    do {
+        const page = await suiClient.getCoins({ owner, coinType: SUI_COIN_TYPE, cursor });
+        coins.push(...page.data);
+        cursor = page.hasNextPage ? page.nextCursor : null;
+    } while (cursor);
+    if (!coins.length) {
+        throw new Error(`No SUI gas coins found for ${owner}`);
+    }
+    const gasCoin = coins.slice().sort((a, b) => {
+        const aBalance = BigInt(a.balance);
+        const bBalance = BigInt(b.balance);
+        if (aBalance === bBalance)
+            return 0;
+        return aBalance < bBalance ? 1 : -1;
+    })[0];
+    const fresh = await suiClient.getObject({ id: gasCoin.coinObjectId });
+    const ref = fresh.data;
+    if (!ref?.objectId || !ref.version || !ref.digest) {
+        throw new Error(`Failed to refresh gas coin object ref for ${gasCoin.coinObjectId}`);
+    }
+    return {
+        objectId: ref.objectId,
+        version: ref.version,
+        digest: ref.digest,
+    };
+}
+async function setFreshGasPayment(suiClient, tx, owner) {
+    tx.setGasPayment([await getFreshGasObjectRef(suiClient, owner)]);
+}
+async function signAndExecuteTransactionWithFreshGas(suiClient, tx, signer, options) {
+    const sender = signer.getPublicKey().toSuiAddress();
+    tx.setSender(sender);
+    await setFreshGasPayment(suiClient, tx, sender);
+    for (let attempt = 0; attempt < 2; attempt++) {
+        try {
+            return await suiClient.signAndExecuteTransaction({
+                signer,
+                transaction: tx,
+                options,
+            });
+        }
+        catch (error) {
+            if (attempt === 0 && isStaleObjectVersionError(error)) {
+                await sleep(STALE_GAS_RETRY_DELAY_MS);
+                await setFreshGasPayment(suiClient, tx, sender);
+                continue;
+            }
+            throw error;
+        }
+    }
+    throw new Error("Transaction failed after refreshing gas payment");
+}
+
 // Copyright (c) 2025 Dipcoin LLC
 async function executeTxBlock(suiClient, tx, signer) {
-    return suiClient.signAndExecuteTransaction({
-        signer,
-        transaction: tx,
-        options: {
-            showObjectChanges: true,
-            showEffects: true,
-            showEvents: true,
-            showInput: true,
-        },
+    return signAndExecuteTransactionWithFreshGas(suiClient, tx, signer, {
+        showObjectChanges: true,
+        showEffects: true,
+        showEvents: true,
+        showInput: true,
     });
 }
 function getDeploymentPerpetualID(deployment, market) {
@@ -16825,7 +16897,8 @@ function getDeploymentPerpetualID(deployment, market) {
 async function getOraclePrice(suiClient, deployment, market) {
     const objId = getPriceOracleObjectId(deployment, market);
     const obj = await suiClient.getObject({ id: objId, options: { showContent: true } });
-    const fields = obj.data?.content?.fields?.price_info?.fields?.price_feed?.fields?.price?.fields;
+    const fields = obj.data?.content?.fields?.price_info?.fields?.price_feed?.fields?.price
+        ?.fields;
     if (!fields)
         throw new Error(`Failed to read oracle price for ${market}`);
     return Number(fields.price.fields.magnitude) / Math.pow(10, Number(fields.expo.fields.magnitude));
@@ -17627,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,
@@ -17651,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);
@@ -17681,7 +17755,7 @@ class DipCoinPerpSDK {
                     : new BigNumber__default["default"](0);
                 const tpOrder = {
                     market,
-                    creator: this.walletAddress,
+                    creator: orderCreator,
                     isLong: !isLong,
                     reduceOnly,
                     postOnly,
@@ -17726,7 +17800,7 @@ class DipCoinPerpSDK {
                     : new BigNumber__default["default"](0);
                 const slOrder = {
                     market,
-                    creator: this.walletAddress,
+                    creator: orderCreator,
                     isLong: !isLong,
                     reduceOnly,
                     postOnly,
@@ -17784,9 +17858,7 @@ class DipCoinPerpSDK {
             return {
                 status: false,
                 data: results,
-                error: results.tpResult?.message ||
-                    results.slResult?.message ||
-                    "Failed to place TP/SL order",
+                error: results.tpResult?.message || results.slResult?.message || "Failed to place TP/SL order",
             };
         }
         catch (error) {
@@ -17800,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) {
@@ -17812,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) {
@@ -18355,12 +18428,8 @@ class DipCoinPerpSDK {
             tpOrderPrice: toNormal(raw.tpOrderPrice),
             slTriggerPrice: toNormal(raw.slTriggerPrice),
             slOrderPrice: toNormal(raw.slOrderPrice),
-            tpPlanId: planOrderType === "takeProfit"
-                ? raw.tpPlanId ?? raw.id ?? null
-                : raw.tpPlanId ?? null,
-            slPlanId: planOrderType === "stopLoss"
-                ? raw.slPlanId ?? raw.id ?? null
-                : raw.slPlanId ?? null,
+            tpPlanId: planOrderType === "takeProfit" ? raw.tpPlanId ?? raw.id ?? null : raw.tpPlanId ?? null,
+            slPlanId: planOrderType === "stopLoss" ? raw.slPlanId ?? raw.id ?? null : raw.slPlanId ?? null,
             tpslType: raw.tpslType,
             createdAt: raw.createdAt,
             updatedAt: raw.updatedAt,
@@ -18713,7 +18782,7 @@ class DipCoinPerpSDK {
      * Build ExchangeOnChain call args for margin adjustments
      */
     buildMarginCallArgs(params, action) {
-        const { amount, accountAddress, symbol, market, perpId, subAccountsMapId, gasBudget, txHash, } = params;
+        const { amount, accountAddress, symbol, market, perpId, subAccountsMapId, gasBudget, txHash } = params;
         if (!this.isPositiveNumber(amount)) {
             throw new Error(`Amount must be greater than zero to ${action} margin`);
         }
@@ -18869,7 +18938,8 @@ class DipCoinPerpSDK {
     }
     async buildMarginTransaction(params, action) {
         const payload = this.buildMarginCallArgs(params, action);
-        const signedMarket = payload.perpID || (payload.market ? this.resolvePerpIdFromDeployment(payload.market) : undefined);
+        const signedMarket = payload.perpID ||
+            (payload.market ? this.resolvePerpIdFromDeployment(payload.market) : undefined);
         if (!signedMarket) {
             throw new Error("PerpetualID is required for signed margin payload");
         }
@@ -19106,7 +19176,10 @@ class DipCoinPerpSDK {
             if (!metadata) {
                 return { status: false, error: "Coin metadata not found" };
             }
-            return { status: true, data: { decimals: metadata.decimals, symbol: metadata.symbol, name: metadata.name } };
+            return {
+                status: true,
+                data: { decimals: metadata.decimals, symbol: metadata.symbol, name: metadata.name },
+            };
         }
         catch (error) {
             return { status: false, error: formatError(error) };
@@ -19220,7 +19293,8 @@ class DipCoinPerpSDK {
         // to catch up before submitting the PTB. Public RPC backends can disagree by
         // a few seconds, so target a timestamp that is already ~10s old.
         const start = Date.now();
-        while (true) {
+        const deadline = start + 180_000;
+        while (Date.now() <= deadline) {
             const clock = await this.suiClient.getObject({
                 id: "0x6",
                 options: { showContent: true },
@@ -19231,7 +19305,7 @@ class DipCoinPerpSDK {
             const waitMs = timestamp - clockMs + 10_000;
             if (waitMs <= 0)
                 return;
-            if (Date.now() - start + waitMs > 180_000) {
+            if (Date.now() + waitMs > deadline) {
                 throw new Error(`Signed price feed is too far ahead of Sui Clock (${Math.ceil(waitMs / 1000)}s). Try again later.`);
             }
             await this.sleep(Math.min(waitMs, 15_000));
@@ -19244,7 +19318,8 @@ class DipCoinPerpSDK {
         const maxTimestamp = Math.max(...timestamps);
         const minTimestamp = Math.min(...timestamps);
         const start = Date.now();
-        while (true) {
+        const deadline = start + 180_000;
+        while (Date.now() <= deadline) {
             const clock = await this.suiClient.getObject({
                 id: "0x6",
                 options: { showContent: true },
@@ -19259,7 +19334,7 @@ class DipCoinPerpSDK {
                 }
                 return;
             }
-            if (Date.now() - start + waitMs > 180_000) {
+            if (Date.now() + waitMs > deadline) {
                 throw new Error(`Signed price feed is too far ahead of Sui Clock (${Math.ceil(waitMs / 1000)}s). Try again later.`);
             }
             await this.sleep(Math.min(waitMs, 15_000));
@@ -19338,10 +19413,7 @@ class DipCoinPerpSDK {
                 await this.sleep(2_000 * (attempt + 1));
                 continue;
             }
-            return Array.from(new Map(entries.map((feed) => [
-                Buffer.from(feed.payload).toString("hex"),
-                feed,
-            ])).values());
+            return Array.from(new Map(entries.map((feed) => [Buffer.from(feed.payload).toString("hex"), feed])).values());
         }
         throw lastClockError || new Error("Failed to fetch usable signed price feed chunks");
     }
@@ -19444,11 +19516,9 @@ class DipCoinPerpSDK {
         return { nav, tx: t };
     }
     async signAndExecuteVaultTx(tx) {
-        tx.setSender(this.keypair.getPublicKey().toSuiAddress());
-        return await this.suiClient.signAndExecuteTransaction({
-            signer: this.keypair,
-            transaction: tx,
-            options: { showEffects: true, showObjectChanges: true },
+        return signAndExecuteTransactionWithFreshGas(this.suiClient, tx, this.keypair, {
+            showEffects: true,
+            showObjectChanges: true,
         });
     }
     /**
@@ -20146,9 +20216,13 @@ function tryAutoBindReferral(sdk) {
         try {
             fs__default["default"].writeFileSync(markerPath, "");
         }
-        catch { }
+        catch {
+            // Marker creation is best-effort; retrying referral binding is harmless.
+        }
     })
-        .catch(() => { });
+        .catch(() => {
+        // Auto-binding should never block normal CLI startup.
+    });
 }
 /**
  * Get or create the SDK instance (singleton).
@@ -20668,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();
@@ -20675,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,
@@ -20690,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",
                 };
             }
@@ -20698,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",
                 };
             }
@@ -20831,7 +20993,10 @@ function registerMarketCommands(program) {
             const ob = result.data;
             console.log(`\n  Order Book: ${symbol}`);
             console.log("  --- Asks (sell) ---");
-            ob.asks.slice(0, 10).reverse().forEach((a) => {
+            ob.asks
+                .slice(0, 10)
+                .reverse()
+                .forEach((a) => {
                 console.log(`    ${formatWei(a.price).padStart(14)}  |  ${formatWei(a.quantity)}`);
             });
             console.log("  --- Bids (buy) ---");
@@ -21138,7 +21303,9 @@ function registerVaultCommands(program) {
                 return handleError(result.error);
             let vaults = result.data || [];
             if (!vaults.length)
-                return isJson(program) ? printJson({ records: [], total: 0, pageNum: 1, pageSize: 10 }) : console.log("No vaults found.");
+                return isJson(program)
+                    ? printJson({ records: [], total: 0, pageNum: 1, pageSize: 10 })
+                    : console.log("No vaults found.");
             // Client-side filter
             const filter = opts.filter;
             if (filter && filter !== "All") {
@@ -21166,7 +21333,16 @@ function registerVaultCommands(program) {
                 return printJson({ records: pageVaults, total, pageNum, pageSize, totalPages });
             if (!pageVaults.length)
                 return console.log(`No vaults on page ${pageNum}. Total: ${total}, pages: ${totalPages}.`);
-            printTable(["Name", "Vault ID", "TVL (USDC)", "APR (%)", "Depositors", "Age (d)", "Deposit", "Status"], pageVaults.map((v) => {
+            printTable([
+                "Name",
+                "Vault ID",
+                "TVL (USDC)",
+                "APR (%)",
+                "Depositors",
+                "Age (d)",
+                "Deposit",
+                "Status",
+            ], pageVaults.map((v) => {
                 const tvl = new BigNumber__default["default"](v.tvl || "0").dividedBy(new BigNumber__default["default"](10).pow(18)).toFixed(2);
                 const apr = new BigNumber__default["default"](v.apr || "0").dividedBy(new BigNumber__default["default"](10).pow(14)).toFixed(2);
                 const depositors = new BigNumber__default["default"](v.currentDepositors || "0")
@@ -21208,7 +21384,10 @@ function registerVaultCommands(program) {
                 ["Name", d.name || "-"],
                 ["Creator", d.creator || "-"],
                 ["Trader", d.trader || "-"],
-                ["Deposit Status", d.deposit_status === true || d.deposit_status === "true" ? "Open" : "Closed"],
+                [
+                    "Deposit Status",
+                    d.deposit_status === true || d.deposit_status === "true" ? "Open" : "Closed",
+                ],
                 ["Total Shares", formatWeiValue(d.total_shares)],
                 ["Max Cap", formatWeiValue(d.max_cap)],
                 ["Min Deposit", formatWeiValue(d.min_deposit_amount)],
@@ -21480,7 +21659,10 @@ function registerVaultCommands(program) {
         .action(async (vaultId, amount) => {
         try {
             const sdk = getSDK();
-            const tx = await sdk.setVaultMinDepositAmount({ vaultID: vaultId, minDepositAmount: parseAmount(amount) });
+            const tx = await sdk.setVaultMinDepositAmount({
+                vaultID: vaultId,
+                minDepositAmount: parseAmount(amount),
+            });
             printTxResult(program, tx, `Min deposit set to ${amount} USDC.`);
         }
         catch (e) {
@@ -21497,7 +21679,10 @@ function registerVaultCommands(program) {
         try {
             const sdk = getSDK();
             const enabled = !opts.disable;
-            const tx = await sdk.setVaultAutoCloseOnWithdraw({ vaultID: vaultId, autoCloseOnWithdraw: enabled });
+            const tx = await sdk.setVaultAutoCloseOnWithdraw({
+                vaultID: vaultId,
+                autoCloseOnWithdraw: enabled,
+            });
             printTxResult(program, tx, `Auto-close on withdraw ${enabled ? "enabled" : "disabled"}.`);
         }
         catch (e) {