dipcoin-cli 0.5.0 → 0.6.0

package/dist/cli.cjs

@@ -1,27 +1,31 @@
 #!/usr/bin/env node
 'use strict';
 
+Object.defineProperty(exports, '__esModule', { value: true });
+
 var commander = require('commander');
 var dotenv = require('dotenv');
+var path = require('path');
+var os = require('os');
+var fs = require('fs');
+var ed25519 = require('@mysten/sui/keypairs/ed25519');
 var perpTsLibrary = require('@dipcoinlab/perp-ts-library');
 var transactions = require('@mysten/sui/transactions');
 var BigNumber = require('bignumber.js');
 var pythSuiJs = require('@pythnetwork/pyth-sui-js');
 var child_process = require('child_process');
-var ed25519 = require('@mysten/sui/keypairs/ed25519');
 var utils = require('@mysten/sui/utils');
 var buffer = require('buffer');
-var fs = require('fs');
-var path = require('path');
 var url = require('url');
 var Table = require('cli-table3');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
 var dotenv__default = /*#__PURE__*/_interopDefaultLegacy(dotenv);
-var BigNumber__default = /*#__PURE__*/_interopDefaultLegacy(BigNumber);
-var fs__default = /*#__PURE__*/_interopDefaultLegacy(fs);
 var path__default = /*#__PURE__*/_interopDefaultLegacy(path);
+var os__default = /*#__PURE__*/_interopDefaultLegacy(os);
+var fs__default = /*#__PURE__*/_interopDefaultLegacy(fs);
+var BigNumber__default = /*#__PURE__*/_interopDefaultLegacy(BigNumber);
 var Table__default = /*#__PURE__*/_interopDefaultLegacy(Table);
 
 // Copyright (c) 2025 Dipcoin LLC
@@ -41,6 +45,7 @@ function initSDKOptions(options) {
         apiBaseUrl: options.apiBaseUrl || DEFAULT_API_URLS[options.network],
         network: options.network,
         customRpc: options.customRpc,
+        subAccountKey: options.subAccountKey,
     };
 }
 
@@ -9366,6 +9371,7 @@ 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",
+    VAULTS_BY_CREATOR: "/api/perp-vault-api/public/vaults/by-creator",
 };
 /**
  * Onboarding message for authentication
@@ -16449,7 +16455,7 @@ function findPackageRoot(startDir) {
         if (fs__default["default"].existsSync(packageJsonPath)) {
             try {
                 const packageJson = JSON.parse(fs__default["default"].readFileSync(packageJsonPath, "utf-8"));
-                if (packageJson.name === "@dipcoinlab/perp-client-ts") {
+                if (packageJson.name === "dipcoin-cli") {
                     return currentDir;
                 }
             }
@@ -16514,6 +16520,78 @@ function readFile(filePath) {
     return config;
 }
 
+// Copyright (c) 2025 Dipcoin LLC
+const CACHE_DIR = path__default["default"].join(os__default["default"].homedir(), ".config", "dipcoin", "jwt");
+/** Safety margin: treat token as expired 60s before actual expiry */
+const EXPIRY_MARGIN_S = 60;
+function getCachePath(address) {
+    return path__default["default"].join(CACHE_DIR, `${address}.json`);
+}
+function parseJwtExp(token) {
+    try {
+        const parts = token.split(".");
+        if (parts.length !== 3)
+            return null;
+        const payload = JSON.parse(Buffer.from(parts[1], "base64").toString());
+        return typeof payload.exp === "number" ? payload.exp : null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Load a cached JWT for the given wallet address.
+ * Returns the token string if valid and not expired, otherwise null.
+ */
+function loadCachedJwt(address) {
+    try {
+        const filePath = getCachePath(address);
+        if (!fs__default["default"].existsSync(filePath))
+            return null;
+        const raw = fs__default["default"].readFileSync(filePath, "utf-8");
+        const entry = JSON.parse(raw);
+        const now = Math.floor(Date.now() / 1000);
+        if (entry.exp - EXPIRY_MARGIN_S > now) {
+            return entry.token;
+        }
+        // Expired, clean up
+        fs__default["default"].unlinkSync(filePath);
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Save a JWT to the local cache.
+ */
+function saveCachedJwt(address, token) {
+    try {
+        const exp = parseJwtExp(token);
+        if (!exp)
+            return;
+        fs__default["default"].mkdirSync(CACHE_DIR, { recursive: true });
+        const entry = { token, exp };
+        fs__default["default"].writeFileSync(getCachePath(address), JSON.stringify(entry), { mode: 0o600 });
+    }
+    catch {
+        // Non-fatal: cache write failure is acceptable
+    }
+}
+/**
+ * Remove cached JWT for the given address.
+ */
+function clearCachedJwt(address) {
+    try {
+        const filePath = getCachePath(address);
+        if (fs__default["default"].existsSync(filePath))
+            fs__default["default"].unlinkSync(filePath);
+    }
+    catch {
+        // ignore
+    }
+}
+
 // Copyright (c) 2025 Dipcoin LLC
 /**
  * DipCoin Perpetual Trading SDK
@@ -16554,7 +16632,12 @@ class DipCoinPerpSDK {
         }
         // Initialize sub-account keypair if provided
         if (options.subAccountKey) {
-            this.subKeypair = fromExportedKeypair(options.subAccountKey);
+            if (typeof options.subAccountKey === "string") {
+                this.subKeypair = fromExportedKeypair(options.subAccountKey);
+            }
+            else {
+                this.subKeypair = options.subAccountKey;
+            }
             this.subAddress = this.subKeypair.getPublicKey().toSuiAddress();
         }
         // Get wallet address
@@ -16593,30 +16676,27 @@ class DipCoinPerpSDK {
      */
     async authenticate() {
         try {
-            // If already authenticated and token exists, return it
+            // If already authenticated in this process, return it
             if (this.jwtToken) {
-                return {
-                    status: true,
-                    data: this.jwtToken,
-                };
+                return { status: true, data: this.jwtToken };
+            }
+            // Try loading from local cache
+            const cached = loadCachedJwt(this.walletAddress);
+            if (cached) {
+                this.jwtToken = cached;
+                this.httpClient.setAuthToken(cached);
+                return { status: true, data: cached };
             }
             // Prevent concurrent authentication requests
             if (this.isAuthenticating) {
-                // Wait for ongoing authentication
                 await new Promise((resolve) => setTimeout(resolve, 100));
                 if (this.jwtToken) {
-                    return {
-                        status: true,
-                        data: this.jwtToken,
-                    };
+                    return { status: true, data: this.jwtToken };
                 }
             }
             this.isAuthenticating = true;
-            // 1. Prepare onboarding message
             const messageBytes = new TextEncoder().encode(ONBOARDING_MESSAGE);
-            // 2. Sign the message
             const signature = await signMessage(this.keypair, messageBytes);
-            // 3. Call authorize endpoint to get JWT token
             const response = await this.httpClient.post(API_ENDPOINTS.AUTHORIZE, {
                 userAddress: this.walletAddress,
                 isTermAccepted: true,
@@ -16625,26 +16705,18 @@ class DipCoinPerpSDK {
             if (response.code === 200 && response.data?.token) {
                 this.jwtToken = response.data.token;
                 this.httpClient.setAuthToken(this.jwtToken);
+                saveCachedJwt(this.walletAddress, this.jwtToken);
                 this.isAuthenticating = false;
-                return {
-                    status: true,
-                    data: this.jwtToken,
-                };
+                return { status: true, data: this.jwtToken };
             }
             else {
                 this.isAuthenticating = false;
-                return {
-                    status: false,
-                    error: response.message || "Failed to authenticate",
-                };
+                return { status: false, error: response.message || "Failed to authenticate" };
             }
         }
         catch (error) {
             this.isAuthenticating = false;
-            return {
-                status: false,
-                error: formatError(error),
-            };
+            return { status: false, error: formatError(error) };
         }
     }
     /**
@@ -16655,10 +16727,17 @@ class DipCoinPerpSDK {
         if (!this.subKeypair) {
             return { status: false, error: "Sub-account keypair not configured" };
         }
+        const subAddress = this.subKeypair.getPublicKey().toSuiAddress();
         try {
             if (this.subJwtToken) {
                 return { status: true, data: this.subJwtToken };
             }
+            // Try loading from local cache
+            const cached = loadCachedJwt(subAddress);
+            if (cached) {
+                this.subJwtToken = cached;
+                return { status: true, data: cached };
+            }
             if (this.isSubAuthenticating) {
                 await new Promise((resolve) => setTimeout(resolve, 100));
                 if (this.subJwtToken) {
@@ -16668,7 +16747,6 @@ class DipCoinPerpSDK {
             this.isSubAuthenticating = true;
             const messageBytes = new TextEncoder().encode(ONBOARDING_MESSAGE);
             const signature = await signMessage(this.subKeypair, messageBytes);
-            const subAddress = this.subKeypair.getPublicKey().toSuiAddress();
             const response = await this.httpClient.post(API_ENDPOINTS.AUTHORIZE, {
                 userAddress: subAddress,
                 isTermAccepted: true,
@@ -16676,6 +16754,7 @@ class DipCoinPerpSDK {
             });
             if (response.code === 200 && response.data?.token) {
                 this.subJwtToken = response.data.token;
+                saveCachedJwt(subAddress, this.subJwtToken);
                 this.isSubAuthenticating = false;
                 return { status: true, data: this.subJwtToken };
             }
@@ -16732,6 +16811,10 @@ class DipCoinPerpSDK {
      * Clear JWT token (logout)
      */
     clearAuth() {
+        if (this.jwtToken)
+            clearCachedJwt(this.walletAddress);
+        if (this.subJwtToken && this.subAddress)
+            clearCachedJwt(this.subAddress);
         this.jwtToken = undefined;
         this.subJwtToken = undefined;
         this.httpClient.setAuthToken("");
@@ -17231,7 +17314,7 @@ class DipCoinPerpSDK {
                 const tpOrder = {
                     market,
                     creator: this.walletAddress,
-                    isLong,
+                    isLong: !isLong,
                     reduceOnly,
                     postOnly,
                     orderbookOnly,
@@ -17276,7 +17359,7 @@ class DipCoinPerpSDK {
                 const slOrder = {
                     market,
                     creator: this.walletAddress,
-                    isLong,
+                    isLong: !isLong,
                     reduceOnly,
                     postOnly,
                     orderbookOnly,
@@ -17552,36 +17635,7 @@ class DipCoinPerpSDK {
      */
     async getTradingPairs() {
         try {
-            // Ensure authenticated before making request
-            const authResult = await this.authenticate();
-            if (!authResult.status) {
-                return {
-                    status: false,
-                    error: authResult.error || "Authentication failed",
-                };
-            }
             const response = await this.httpClient.get(API_ENDPOINTS.GET_TRADING_PAIRS);
-            // Handle JWT expiration
-            if (response.code === 1000) {
-                this.clearAuth();
-                const retryAuth = await this.authenticate();
-                if (retryAuth.status) {
-                    const retryResponse = await this.httpClient.get(API_ENDPOINTS.GET_TRADING_PAIRS);
-                    if (retryResponse.code === 200) {
-                        const pairs = Array.isArray(retryResponse.data)
-                            ? retryResponse.data
-                            : retryResponse.data?.data || [];
-                        return {
-                            status: true,
-                            data: pairs,
-                        };
-                    }
-                }
-                return {
-                    status: false,
-                    error: "Authentication expired and refresh failed",
-                };
-            }
             if (response.code === 200) {
                 const pairs = Array.isArray(response.data) ? response.data : response.data?.data || [];
                 return {
@@ -17715,12 +17769,6 @@ class DipCoinPerpSDK {
                     error: "Symbol is required",
                 };
             }
-            // Market API endpoints typically don't require authentication
-            // But we'll try to authenticate if possible for consistency
-            // If authentication fails, we'll still try to fetch the order book
-            await this.authenticate().catch(() => {
-                // Ignore authentication errors for market data
-            });
             const params = {
                 symbol,
             };
@@ -17873,12 +17921,6 @@ class DipCoinPerpSDK {
                     error: "Symbol is required",
                 };
             }
-            // Market API endpoints typically don't require authentication
-            // But we'll try to authenticate if possible for consistency
-            // If authentication fails, we'll still try to fetch the ticker
-            await this.authenticate().catch(() => {
-                // Ignore authentication errors for market data
-            });
             const params = {
                 symbol,
             };
@@ -18078,6 +18120,10 @@ class DipCoinPerpSDK {
                 queryParams.pageSize = params.pageSize;
             if (params?.parentAddress)
                 queryParams.parentAddress = params.parentAddress;
+            if (params?.beginTime)
+                queryParams.beginTime = params.beginTime;
+            if (params?.endTime)
+                queryParams.endTime = params.endTime;
             let response = await this.httpClient.get(API_ENDPOINTS.HISTORY_ORDERS, { params: queryParams });
             if (response.code === 1000) {
                 this.clearAuth();
@@ -18117,6 +18163,8 @@ class DipCoinPerpSDK {
                 queryParams.pageSize = params.pageSize;
             if (params?.parentAddress)
                 queryParams.parentAddress = params.parentAddress;
+            if (params?.beginTime)
+                queryParams.beginTime = params.beginTime;
             let response = await this.httpClient.get(API_ENDPOINTS.FUNDING_SETTLEMENTS, { params: queryParams });
             if (response.code === 1000) {
                 this.clearAuth();
@@ -18154,6 +18202,8 @@ class DipCoinPerpSDK {
                 queryParams.pageSize = params.pageSize;
             if (params?.parentAddress)
                 queryParams.parentAddress = params.parentAddress;
+            if (params?.beginTime)
+                queryParams.beginTime = params.beginTime;
             let response = await this.httpClient.get(API_ENDPOINTS.BALANCE_CHANGES, { params: queryParams });
             if (response.code === 1000) {
                 this.clearAuth();
@@ -18184,7 +18234,6 @@ class DipCoinPerpSDK {
             if (!symbol) {
                 return { status: false, error: "Symbol is required" };
             }
-            await this.authenticate().catch(() => { });
             const response = await this.httpClient.get(API_ENDPOINTS.ORACLE, { params: { symbol } });
             if (response.code === 200 && response.data !== undefined) {
                 return { status: true, data: String(response.data) };
@@ -18470,9 +18519,9 @@ class DipCoinPerpSDK {
      * Get all coin balances on-chain for the current wallet address
      * @returns Array of coin balances with coinType and totalBalance
      */
-    async getAllBalances() {
+    async getAllBalances(owner) {
         try {
-            const balances = await this.suiClient.getAllBalances({ owner: this.walletAddress });
+            const balances = await this.suiClient.getAllBalances({ owner: owner || this.walletAddress });
             return { status: true, data: balances };
         }
         catch (error) {
@@ -18495,6 +18544,416 @@ class DipCoinPerpSDK {
             return { status: false, error: formatError(error) };
         }
     }
+    // =====================================================
+    // Vault (on-chain contract) Operations
+    // =====================================================
+    //
+    // Vault functions live in a SEPARATE package from the exchange.
+    // The library's ExchangeOnChain uses getPackageID() (exchange pkg)
+    // for vault moveCall targets, causing TypeMismatch errors.
+    // We build vault transactions manually with the correct vault package.
+    // =====================================================
+    getVaultPackageId() {
+        const pkg = this.deploymentConfig?.vaultPackage;
+        if (!pkg)
+            throw new Error("Deployment config missing vaultPackage");
+        return pkg;
+    }
+    getVaultConfigId() {
+        const id = this.deploymentConfig?.objects?.VaultConfig?.id;
+        if (!id)
+            throw new Error("Deployment config missing VaultConfig id");
+        return id;
+    }
+    getBankId() {
+        const id = this.deploymentConfig?.objects?.Bank?.id;
+        if (!id)
+            throw new Error("Deployment config missing Bank id");
+        return id;
+    }
+    getTxIndexerId() {
+        const id = this.deploymentConfig?.objects?.TxIndexer?.id;
+        if (!id)
+            throw new Error("Deployment config missing TxIndexer id");
+        return id;
+    }
+    getSubAccountsId() {
+        const id = this.deploymentConfig?.objects?.SubAccounts?.id;
+        if (!id)
+            throw new Error("Deployment config missing SubAccounts id");
+        return id;
+    }
+    getCurrencyType() {
+        const dt = this.deploymentConfig?.objects?.Currency?.dataType;
+        if (!dt)
+            throw new Error("Deployment config missing Currency dataType");
+        return dt;
+    }
+    getMarketSymbols() {
+        return Object.keys(this.deploymentConfig?.markets || {});
+    }
+    getVaultPerpetualId(symbol) {
+        const id = this.deploymentConfig?.markets?.[symbol]?.Objects?.Perpetual?.id;
+        if (!id)
+            throw new Error(`Deployment config missing Perpetual id for ${symbol}`);
+        return id;
+    }
+    getVaultPriceInfoObjectId(symbol) {
+        const id = this.deploymentConfig?.markets?.[symbol]?.Objects?.PriceInfoObject?.id;
+        if (!id)
+            throw new Error(`Deployment config missing PriceInfoObject id for ${symbol}`);
+        return id;
+    }
+    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();
+        // On testnet, prepend price oracle updates so PriceInfoObjects are fresh
+        if (this.options.network === "testnet" && this.transactionBuilder) {
+            const prices = [];
+            for (const sym of symbols) {
+                try {
+                    const oraclePrice = await this.exchangeOnChain.getOraclePrice(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) {
+                this.transactionBuilder.price_info_batchSetOraclePriceTx({ prices }, t);
+            }
+        }
+        const [nav] = t.moveCall({
+            target: `${vaultPkg}::vault::new_vault_nav`,
+            arguments: [
+                t.object(this.getDeploymentProtocolConfigId()),
+                t.object(this.getVaultConfigId()),
+                t.object(vaultID),
+                t.object(this.getBankId()),
+            ],
+            typeArguments: [currencyType],
+        });
+        for (const sym of symbols) {
+            const perpId = this.getVaultPerpetualId(sym);
+            const priceInfoId = this.getVaultPriceInfoObjectId(sym);
+            t.moveCall({
+                target: `${vaultPkg}::vault::compute_perpetual_position_value`,
+                arguments: [nav, t.object("0x6"), t.object(perpId), t.object(priceInfoId)],
+                typeArguments: [],
+            });
+        }
+        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 },
+        });
+    }
+    /**
+     * Create a new on-chain vault
+     */
+    async createVault(args) {
+        const tx = new transactions.Transaction();
+        const vaultPkg = this.getVaultPackageId();
+        tx.moveCall({
+            target: `${vaultPkg}::vault::create_vault`,
+            arguments: [
+                tx.object(this.getDeploymentProtocolConfigId()),
+                tx.object("0x6"),
+                tx.object(this.getVaultConfigId()),
+                tx.object(this.getSubAccountsId()),
+                tx.object(this.getBankId()),
+                tx.object(this.getTxIndexerId()),
+                tx.pure.string(args.name),
+                tx.pure.address(args.trader),
+                tx.pure.u128(formatNormalToWei(args.maxCap)),
+                tx.pure.u128(formatNormalToWei(args.minDepositAmount)),
+                tx.pure.u128(args.creatorMinimumShareRatio),
+                tx.pure.u128(args.creatorProfitShareRatio),
+                tx.pure.u128(formatNormalToWei(args.initialAmount)),
+            ],
+            typeArguments: [this.getCurrencyType()],
+        });
+        return this.signAndExecuteVaultTx(tx);
+    }
+    /**
+     * Deposit USDC into a vault
+     */
+    async depositToVault(args) {
+        const { nav, tx } = await this.buildVaultNavTransaction(args.vaultID, args.markets);
+        const vaultPkg = this.getVaultPackageId();
+        tx.moveCall({
+            target: `${vaultPkg}::vault::deposit`,
+            arguments: [
+                tx.object(this.getDeploymentProtocolConfigId()),
+                tx.object(this.getVaultConfigId()),
+                tx.object("0x6"),
+                tx.object(this.getBankId()),
+                tx.object(this.getTxIndexerId()),
+                tx.object(args.vaultID),
+                nav,
+                tx.pure.u128(formatNormalToWei(args.amount)),
+            ],
+            typeArguments: [this.getCurrencyType()],
+        });
+        return this.signAndExecuteVaultTx(tx);
+    }
+    /**
+     * Request withdrawal from a vault (by share amount)
+     */
+    async requestWithdrawFromVault(args) {
+        const tx = new transactions.Transaction();
+        const vaultPkg = this.getVaultPackageId();
+        tx.moveCall({
+            target: `${vaultPkg}::vault::request_withdraw`,
+            arguments: [
+                tx.object(this.getDeploymentProtocolConfigId()),
+                tx.object(this.getVaultConfigId()),
+                tx.object("0x6"),
+                tx.object(args.vaultID),
+                tx.pure.u128(formatNormalToWei(args.shares)),
+            ],
+            typeArguments: [this.getCurrencyType()],
+        });
+        return this.signAndExecuteVaultTx(tx);
+    }
+    /**
+     * Fill pending withdrawal requests (creator/operator only)
+     */
+    async fillWithdrawalRequests(args) {
+        const { nav, tx } = await this.buildVaultNavTransaction(args.vaultID, args.markets);
+        const vaultPkg = this.getVaultPackageId();
+        const requestVec = tx.makeMoveVec({
+            elements: args.withdrawalRequestIDs.map((id) => tx.object(id)),
+        });
+        tx.moveCall({
+            target: `${vaultPkg}::vault::fill_withdrawal_requests`,
+            arguments: [
+                tx.object(this.getDeploymentProtocolConfigId()),
+                tx.object(this.getVaultConfigId()),
+                tx.object("0x6"),
+                tx.object(this.getBankId()),
+                tx.object(this.getTxIndexerId()),
+                tx.object(args.vaultID),
+                nav,
+                requestVec,
+            ],
+            typeArguments: [this.getCurrencyType()],
+        });
+        return this.signAndExecuteVaultTx(tx);
+    }
+    /**
+     * Close a vault (creator only)
+     */
+    async closeVault(args) {
+        const { nav, tx } = await this.buildVaultNavTransaction(args.vaultID, args.markets);
+        const vaultPkg = this.getVaultPackageId();
+        tx.moveCall({
+            target: `${vaultPkg}::vault::close_vault_v2`,
+            arguments: [
+                tx.object(this.getDeploymentProtocolConfigId()),
+                tx.object(this.getVaultConfigId()),
+                tx.object(this.getSubAccountsId()),
+                tx.object(args.vaultID),
+                tx.object(this.getBankId()),
+                tx.object("0x6"),
+                nav,
+            ],
+            typeArguments: [this.getCurrencyType()],
+        });
+        return this.signAndExecuteVaultTx(tx);
+    }
+    /**
+     * Remove a closed vault (after all funds claimed)
+     */
+    async removeVault(args) {
+        const tx = new transactions.Transaction();
+        const vaultPkg = this.getVaultPackageId();
+        tx.moveCall({
+            target: `${vaultPkg}::vault::remove_vault`,
+            arguments: [
+                tx.object(this.getDeploymentProtocolConfigId()),
+                tx.object(this.getVaultConfigId()),
+                tx.object(this.getBankId()),
+                tx.object(args.vaultID),
+            ],
+            typeArguments: [this.getCurrencyType()],
+        });
+        return this.signAndExecuteVaultTx(tx);
+    }
+    /**
+     * Claim funds from a closed vault
+     */
+    async claimClosedVaultFunds(args) {
+        const tx = new transactions.Transaction();
+        const vaultPkg = this.getVaultPackageId();
+        tx.moveCall({
+            target: `${vaultPkg}::vault::claim_closed_vault_funds`,
+            arguments: [
+                tx.object(this.getDeploymentProtocolConfigId()),
+                tx.object(this.getVaultConfigId()),
+                tx.object(this.getBankId()),
+                tx.object(this.getTxIndexerId()),
+                tx.object(args.vaultID),
+            ],
+            typeArguments: [this.getCurrencyType()],
+        });
+        return this.signAndExecuteVaultTx(tx);
+    }
+    /**
+     * Set the trader address for a vault (creator only)
+     */
+    async setVaultTrader(args) {
+        const tx = new transactions.Transaction();
+        const vaultPkg = this.getVaultPackageId();
+        tx.moveCall({
+            target: `${vaultPkg}::vault::set_trader`,
+            arguments: [
+                tx.object(this.getDeploymentProtocolConfigId()),
+                tx.object(this.getVaultConfigId()),
+                tx.object(args.vaultID),
+                tx.object(this.getSubAccountsId()),
+                tx.pure.address(args.newTrader),
+            ],
+            typeArguments: [this.getCurrencyType()],
+        });
+        return this.signAndExecuteVaultTx(tx);
+    }
+    /**
+     * Add or remove a sub-trader for a vault
+     */
+    async setVaultSubTrader(args) {
+        const tx = new transactions.Transaction();
+        const vaultPkg = this.getVaultPackageId();
+        tx.moveCall({
+            target: `${vaultPkg}::vault::set_sub_trader`,
+            arguments: [
+                tx.object(this.getDeploymentProtocolConfigId()),
+                tx.object(this.getVaultConfigId()),
+                tx.object(args.vaultID),
+                tx.object(this.getSubAccountsId()),
+                tx.pure.address(args.subTrader),
+                tx.pure.bool(args.status),
+            ],
+            typeArguments: [this.getCurrencyType()],
+        });
+        return this.signAndExecuteVaultTx(tx);
+    }
+    /**
+     * Enable or disable deposits to a vault (creator only)
+     */
+    async setVaultDepositStatus(args) {
+        const tx = new transactions.Transaction();
+        const vaultPkg = this.getVaultPackageId();
+        tx.moveCall({
+            target: `${vaultPkg}::vault::set_deposit_status`,
+            arguments: [
+                tx.object(this.getDeploymentProtocolConfigId()),
+                tx.object(this.getVaultConfigId()),
+                tx.object(args.vaultID),
+                tx.pure.bool(args.status),
+            ],
+            typeArguments: [this.getCurrencyType()],
+        });
+        return this.signAndExecuteVaultTx(tx);
+    }
+    /**
+     * Set maximum USDC cap for a vault (creator only)
+     */
+    async setVaultMaxCap(args) {
+        const tx = new transactions.Transaction();
+        const vaultPkg = this.getVaultPackageId();
+        tx.moveCall({
+            target: `${vaultPkg}::vault::set_max_cap`,
+            arguments: [
+                tx.object(this.getDeploymentProtocolConfigId()),
+                tx.object(this.getVaultConfigId()),
+                tx.object(args.vaultID),
+                tx.pure.u128(formatNormalToWei(args.maxCap)),
+            ],
+            typeArguments: [this.getCurrencyType()],
+        });
+        return this.signAndExecuteVaultTx(tx);
+    }
+    /**
+     * Set minimum deposit amount for a vault (creator only)
+     */
+    async setVaultMinDepositAmount(args) {
+        const tx = new transactions.Transaction();
+        const vaultPkg = this.getVaultPackageId();
+        tx.moveCall({
+            target: `${vaultPkg}::vault::set_min_deposit_amount`,
+            arguments: [
+                tx.object(this.getDeploymentProtocolConfigId()),
+                tx.object(this.getVaultConfigId()),
+                tx.object(args.vaultID),
+                tx.pure.u128(formatNormalToWei(args.minDepositAmount)),
+            ],
+            typeArguments: [this.getCurrencyType()],
+        });
+        return this.signAndExecuteVaultTx(tx);
+    }
+    /**
+     * Enable or disable auto-close on withdrawal (creator only)
+     */
+    async setVaultAutoCloseOnWithdraw(args) {
+        const tx = new transactions.Transaction();
+        const vaultPkg = this.getVaultPackageId();
+        tx.moveCall({
+            target: `${vaultPkg}::vault::set_auto_close_on_withdraw`,
+            arguments: [
+                tx.object(this.getDeploymentProtocolConfigId()),
+                tx.object(this.getVaultConfigId()),
+                tx.object(args.vaultID),
+                tx.pure.bool(args.autoCloseOnWithdraw),
+            ],
+            typeArguments: [this.getCurrencyType()],
+        });
+        return this.signAndExecuteVaultTx(tx);
+    }
+    /**
+     * Read vault object data from chain
+     */
+    async getVaultInfo(vaultID) {
+        try {
+            const obj = await this.suiClient.getObject({
+                id: vaultID,
+                options: { showContent: true, showType: true },
+            });
+            if (!obj.data?.content || obj.data.content.dataType !== "moveObject") {
+                return { status: false, error: "Vault object not found or not a Move object" };
+            }
+            return { status: true, data: obj.data.content.fields };
+        }
+        catch (error) {
+            return { status: false, error: formatError(error) };
+        }
+    }
+    /**
+     * List vaults created by a specific address via server API.
+     */
+    async listVaults(creatorAddress) {
+        try {
+            const address = creatorAddress || this.walletAddress;
+            const response = await this.httpClient.get(API_ENDPOINTS.VAULTS_BY_CREATOR, {
+                params: { address },
+            });
+            if (response.code === 200) {
+                return { status: true, data: response.data || [] };
+            }
+            return { status: false, error: response.message || "Failed to list vaults" };
+        }
+        catch (error) {
+            return { status: false, error: formatError(error) };
+        }
+    }
 }
 
 // Copyright (c) 2025 Dipcoin LLC
@@ -18509,33 +18968,133 @@ function initDipCoinPerpSDK(privateKey, options) {
     return new DipCoinPerpSDK(privateKey, sdkOptions);
 }
 
-dotenv__default["default"].config();
-let sdkInstance = null;
-function getSDK() {
-    if (sdkInstance)
-        return sdkInstance;
-    const privateKey = process.env.PRIVATE_KEY;
-    if (!privateKey) {
-        console.error("Error: PRIVATE_KEY not set in .env");
+const globalEnv = path__default["default"].join(os__default["default"].homedir(), ".config", "dipcoin", "env");
+const localEnv = path__default["default"].resolve(process.cwd(), ".env");
+if (fs__default["default"].existsSync(globalEnv)) {
+    dotenv__default["default"].config({ path: globalEnv });
+}
+else if (fs__default["default"].existsSync(localEnv)) {
+    dotenv__default["default"].config({ path: localEnv });
+}
+// Cache SDK instances by a composite key
+const sdkCache = new Map();
+/**
+ * Derive an Ed25519 keypair from a mnemonic at a given account index.
+ * Uses SLIP-0010 path: m/44'/784'/{index}'/0'/0'
+ */
+function deriveKeypairFromMnemonic(mnemonic, index) {
+    const path = `m/44'/784'/${index}'/0'/0'`;
+    return ed25519.Ed25519Keypair.deriveKeypair(mnemonic, path);
+}
+/**
+ * Read and validate MNEMONIC from env.
+ */
+function getMnemonic() {
+    const mnemonic = process.env.MNEMONIC;
+    if (!mnemonic) {
+        console.error(`Error: MNEMONIC not set. Create config at ${globalEnv}`);
         process.exit(1);
     }
-    const network = process.env.NETWORK || "testnet";
-    const subAccountKey = process.env.SUB_ACCOUNT_KEY || undefined;
-    sdkInstance = initDipCoinPerpSDK(privateKey, {
-        network,
-        ...(subAccountKey ? { subAccountKey } : {}),
-    });
-    return sdkInstance;
+    return mnemonic;
 }
-function getVaultAddress(cmdVault) {
-    return cmdVault || process.env.VAULT_ADDRESS || undefined;
+/**
+ * Get the network from env.
+ */
+function getNetwork() {
+    return process.env.NETWORK || "testnet";
 }
-async function ensureAuth(sdk) {
-    const auth = await sdk.authenticate();
-    if (!auth.status) {
-        console.error("Authentication failed:", auth.error);
-        process.exit(1);
+/**
+ * Trading mode SDK: main keypair = index 0, sub keypair = index N.
+ * Used for order signing where creator = main address, signer = sub keypair.
+ * When no vaultIndex provided, returns SDK with main account only (index 0).
+ */
+function getSDK(vaultIndex) {
+    const cacheKey = `trading:${vaultIndex ?? "main"}`;
+    if (sdkCache.has(cacheKey))
+        return sdkCache.get(cacheKey);
+    const mnemonic = getMnemonic();
+    const network = getNetwork();
+    const mainKeypair = deriveKeypairFromMnemonic(mnemonic, 0);
+    if (vaultIndex !== undefined && vaultIndex > 0) {
+        const subKeypair = deriveKeypairFromMnemonic(mnemonic, vaultIndex);
+        const sdk = initDipCoinPerpSDK(mainKeypair, { network, subAccountKey: subKeypair });
+        sdkCache.set(cacheKey, sdk);
+        return sdk;
+    }
+    const sdk = initDipCoinPerpSDK(mainKeypair, { network });
+    sdkCache.set(cacheKey, sdk);
+    return sdk;
+}
+/**
+ * Vault on-chain mode SDK: main keypair = index N.
+ * Used for vault's own deposit/withdraw/balance where the vault keypair signs the tx.
+ */
+function getVaultSDK(vaultIndex) {
+    const cacheKey = `vault:${vaultIndex}`;
+    if (sdkCache.has(cacheKey))
+        return sdkCache.get(cacheKey);
+    const mnemonic = getMnemonic();
+    const network = getNetwork();
+    const vaultKeypair = deriveKeypairFromMnemonic(mnemonic, vaultIndex);
+    const sdk = initDipCoinPerpSDK(vaultKeypair, { network });
+    sdkCache.set(cacheKey, sdk);
+    return sdk;
+}
+/**
+ * Resolve vault address from vault index or explicit address.
+ * Returns undefined for main account (no vault).
+ */
+function resolveVaultAddress(vaultIndex, vaultAddr) {
+    if (vaultAddr)
+        return vaultAddr;
+    if (vaultIndex !== undefined && vaultIndex > 0) {
+        const keypair = deriveKeypairFromMnemonic(getMnemonic(), vaultIndex);
+        return keypair.getPublicKey().toSuiAddress();
+    }
+    return undefined;
+}
+/**
+ * List derived vault addresses from mnemonic.
+ */
+function listVaultAddresses(count) {
+    const mnemonic = getMnemonic();
+    const results = [];
+    for (let i = 0; i < count; i++) {
+        const path = `m/44'/784'/${i}'/0'/0'`;
+        const keypair = deriveKeypairFromMnemonic(mnemonic, i);
+        results.push({ index: i, address: keypair.getPublicKey().toSuiAddress(), path });
+    }
+    return results;
+}
+/**
+ * Get the appropriate SDK for on-chain operations (deposit/withdraw/margin).
+ * Uses the vault's own keypair when vault-index > 0, otherwise main account.
+ */
+function getOnChainSDK(vaultIndex) {
+    return (vaultIndex !== undefined && vaultIndex > 0) ? getVaultSDK(vaultIndex) : getSDK();
+}
+
+/**
+ * Get the global --vault-index value from the root program.
+ */
+function getGlobalVaultIndex(prog) {
+    const opts = prog.opts();
+    if (opts.vaultIndex !== undefined) {
+        const n = Number(opts.vaultIndex);
+        if (isNaN(n) || n < 0) {
+            console.error("Error: --vault-index must be a non-negative integer");
+            process.exit(1);
+        }
+        return n;
     }
+    // Fallback to DEFAULT_VAULT_INDEX env
+    const envDefault = process.env.DEFAULT_VAULT_INDEX;
+    if (envDefault !== undefined) {
+        const n = Number(envDefault);
+        if (!isNaN(n) && n >= 0)
+            return n;
+    }
+    return undefined;
 }
 
 function isJson(cmd) {
@@ -18561,6 +19120,26 @@ function handleError(error) {
     console.error("Error:", typeof error === "string" ? error : error?.message || JSON.stringify(error));
     process.exit(1);
 }
+/**
+ * Print a standard transaction result (success message or failure with exit).
+ */
+function printTxResult(program, tx, successMsg) {
+    const status = tx?.effects?.status?.status;
+    const error = tx?.effects?.status?.error;
+    if (isJson(program))
+        return printJson({ digest: tx?.digest, status, error });
+    if (status === "failure") {
+        console.error(`Failed: ${error}`);
+        process.exit(1);
+    }
+    console.log(`${successMsg} Tx: ${tx?.digest}`);
+}
+/**
+ * Normalize a symbol to include "-PERP" suffix if missing.
+ */
+function normalizeSymbol(s) {
+    return s.includes("-") ? s : `${s}-PERP`;
+}
 
 function registerAccountCommands(program) {
     const account = program.command("account").description("Account operations");
@@ -18570,17 +19149,18 @@ function registerAccountCommands(program) {
         .option("--vault <address>", "Vault address")
         .action(async (opts) => {
         try {
-            const sdk = getSDK();
-            await ensureAuth(sdk);
-            const parentAddress = opts.vault || sdk.address;
+            const vaultIndex = getGlobalVaultIndex(program);
+            const sdk = getSDK(vaultIndex);
+            const parentAddress = opts.vault || resolveVaultAddress(vaultIndex) || sdk.address;
             const result = await sdk.getAccountInfo({ parentAddress });
             if (!result.status || !result.data)
                 return handleError(result.error);
             if (isJson(program))
                 return printJson(result.data);
             const d = result.data;
+            const label = parentAddress !== sdk.address ? parentAddress : sdk.address;
             printTable(["Field", "Value"], [
-                ["Wallet", sdk.address],
+                ["Wallet", label],
                 ["Wallet Balance", formatWei(d.walletBalance)],
                 ["Account Value", formatWei(d.accountValue)],
                 ["Free Collateral", formatWei(d.freeCollateral)],
@@ -18598,18 +19178,10 @@ function registerAccountCommands(program) {
         .argument("<amount>", "Amount in USDC")
         .action(async (amount) => {
         try {
-            const sdk = getSDK();
+            const vaultIndex = getGlobalVaultIndex(program);
+            const sdk = getOnChainSDK(vaultIndex);
             const tx = await sdk.depositToBank(Number(amount));
-            const status = tx?.effects?.status?.status;
-            const error = tx?.effects?.status?.error;
-            if (isJson(program))
-                return printJson({ digest: tx?.digest, status, error });
-            if (status === "failure") {
-                console.error(`Deposit ${amount} USDC failed. Tx: ${tx?.digest}`);
-                console.error(`Error: ${error}`);
-                process.exit(1);
-            }
-            console.log(`Deposit ${amount} USDC succeeded. Tx: ${tx?.digest}`);
+            printTxResult(program, tx, `Deposit ${amount} USDC succeeded.`);
         }
         catch (e) {
             handleError(e);
@@ -18621,18 +19193,10 @@ function registerAccountCommands(program) {
         .argument("<amount>", "Amount in USDC")
         .action(async (amount) => {
         try {
-            const sdk = getSDK();
+            const vaultIndex = getGlobalVaultIndex(program);
+            const sdk = getOnChainSDK(vaultIndex);
             const tx = await sdk.withdrawFromBank(Number(amount));
-            const status = tx?.effects?.status?.status;
-            const error = tx?.effects?.status?.error;
-            if (isJson(program))
-                return printJson({ digest: tx?.digest, status, error });
-            if (status === "failure") {
-                console.error(`Withdraw ${amount} USDC failed. Tx: ${tx?.digest}`);
-                console.error(`Error: ${error}`);
-                process.exit(1);
-            }
-            console.log(`Withdraw ${amount} USDC succeeded. Tx: ${tx?.digest}`);
+            printTxResult(program, tx, `Withdraw ${amount} USDC succeeded.`);
         }
         catch (e) {
             handleError(e);
@@ -18640,18 +19204,41 @@ function registerAccountCommands(program) {
     });
 }
 
-async function placeOrder(program, side, symbol, quantity, opts) {
+/**
+ * Parse amount string: "100USDC" -> 100, "100" -> 100
+ */
+function parseUsdcAmount(raw) {
+    const cleaned = raw.replace(/usdc$/i, "");
+    const val = parseFloat(cleaned);
+    if (isNaN(val) || val <= 0)
+        throw new Error(`Invalid amount: ${raw}`);
+    return val;
+}
+/**
+ * Parse leverage string: "10x" -> "10", "10" -> "10"
+ */
+function parseLeverage(raw) {
+    const cleaned = raw.replace(/x$/i, "");
+    const val = parseFloat(cleaned);
+    if (isNaN(val) || val <= 0)
+        throw new Error(`Invalid leverage: ${raw}`);
+    return cleaned;
+}
+async function placeOrder(program, side, symbol, amount, leverage, opts) {
     try {
-        const sdk = getSDK();
-        await ensureAuth(sdk);
-        const leverage = opts.leverage || "10";
-        const orderType = opts.type?.toUpperCase() === "LIMIT" ? OrderType.LIMIT : OrderType.MARKET;
-        const vault = opts.vault || undefined;
-        if (quantity && opts.usdc)
-            return handleError("Cannot specify both <quantity> and --usdc");
-        if (!quantity && !opts.usdc)
-            return handleError("Must specify either <quantity> or --usdc <amount>");
-        if (opts.usdc) {
+        const vaultIndex = getGlobalVaultIndex(program);
+        const sdk = getSDK(vaultIndex);
+        const lev = parseLeverage(leverage);
+        const orderType = opts.price ? OrderType.LIMIT : OrderType.MARKET;
+        symbol = normalizeSymbol(symbol);
+        let quantity;
+        if (opts.qty) {
+            // Explicit quantity mode
+            quantity = opts.qty;
+        }
+        else {
+            // Default: USDC margin mode
+            const usdcAmount = parseUsdcAmount(amount);
             const tickerResult = await sdk.getTicker(symbol);
             if (!tickerResult.status || !tickerResult.data)
                 return handleError("Failed to get market price for USDC conversion");
@@ -18659,9 +19246,7 @@ async function placeOrder(program, side, symbol, quantity, opts) {
             if (!priceWei || priceWei <= 0)
                 return handleError("Invalid market price");
             const price = priceWei / 1e18;
-            const lev = parseFloat(leverage);
-            const usdcAmount = parseFloat(opts.usdc);
-            const rawQty = usdcAmount * lev / price;
+            const rawQty = usdcAmount * parseFloat(lev) / price;
             let stepSize = 0.01;
             const pairResult = await sdk.getTradingPairs();
             if (pairResult.status && pairResult.data) {
@@ -18682,7 +19267,7 @@ async function placeOrder(program, side, symbol, quantity, opts) {
             quantity = stepped.toFixed(decimals);
             if (parseFloat(quantity) <= 0)
                 return handleError(`USDC amount too small, minimum quantity step is ${stepSize}`);
-            console.log(`USDC ${opts.usdc} -> quantity ${quantity} (price: ${price}, leverage: ${lev}x, step: ${stepSize})`);
+            console.log(`USDC ${usdcAmount} -> quantity ${quantity} (price: ${price}, leverage: ${lev}x, step: ${stepSize})`);
         }
         const perpId = await sdk.getPerpetualID(symbol);
         if (!perpId)
@@ -18693,16 +19278,22 @@ async function placeOrder(program, side, symbol, quantity, opts) {
             side,
             orderType,
             quantity,
-            leverage,
+            leverage: lev,
             reduceOnly: opts.reduceOnly || false,
         };
-        if (orderType === OrderType.LIMIT) {
-            if (!opts.price)
-                return handleError("--price is required for LIMIT orders");
+        if (opts.price) {
             params.price = opts.price;
         }
-        if (vault)
-            params.creator = vault;
+        // --vault <address> as explicit creator override (fallback)
+        if (opts.vault) {
+            params.creator = opts.vault;
+        }
+        else {
+            // With vault-index, the SDK handles creator via sub-keypair automatically
+            const vaultAddr = resolveVaultAddress(vaultIndex);
+            if (vaultAddr)
+                params.creator = vaultAddr;
+        }
         if (opts.tp)
             params.tpTriggerPrice = opts.tp;
         if (opts.sl)
@@ -18723,24 +19314,24 @@ async function placeOrder(program, side, symbol, quantity, opts) {
 function registerTradeCommands(program) {
     const trade = program.command("trade").description("Trading operations");
     const orderOpts = (cmd) => cmd
-        .option("--leverage <n>", "Leverage multiplier", "10")
-        .option("--price <p>", "Order price (required for limit)")
-        .option("--type <type>", "Order type: market or limit", "market")
+        .option("--qty <quantity>", "Specify order quantity instead of USDC margin")
+        .option("--price <p>", "Limit order price (auto-enables limit order)")
         .option("--reduce-only", "Reduce only order")
         .option("--tp <price>", "Take profit trigger price")
         .option("--sl <price>", "Stop loss trigger price")
-        .option("--vault <address>", "Vault/creator address")
-        .option("--usdc <amount>", "Margin amount in USDC (alternative to quantity)");
+        .option("--vault <address>", "Vault/creator address (fallback)");
     orderOpts(trade
         .command("buy")
-        .description("Place a BUY order")
-        .argument("<symbol>", "Trading pair (e.g. BTC-PERP)")
-        .argument("[quantity]", "Order quantity (or use --usdc)")).action((symbol, quantity, opts) => placeOrder(program, OrderSide.BUY, symbol, quantity, opts));
+        .description("Place a BUY order (e.g. trade buy BTC 100USDC 10x)")
+        .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.BUY, symbol, amount, leverage, opts));
     orderOpts(trade
         .command("sell")
-        .description("Place a SELL order")
-        .argument("<symbol>", "Trading pair (e.g. BTC-PERP)")
-        .argument("[quantity]", "Order quantity (or use --usdc)")).action((symbol, quantity, opts) => placeOrder(program, OrderSide.SELL, symbol, quantity, opts));
+        .description("Place a SELL order (e.g. trade sell BTC 100USDC 10x)")
+        .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("cancel")
         .description("Cancel orders by hash")
@@ -18749,13 +19340,14 @@ function registerTradeCommands(program) {
         .option("--vault <address>", "Parent address")
         .action(async (symbol, hashes, opts) => {
         try {
-            const sdk = getSDK();
-            await ensureAuth(sdk);
-            const vault = opts.vault || sdk.address;
+            symbol = normalizeSymbol(symbol);
+            const vaultIndex = getGlobalVaultIndex(program);
+            const sdk = getSDK(vaultIndex);
+            const parentAddress = opts.vault || resolveVaultAddress(vaultIndex) || sdk.address;
             const result = await sdk.cancelOrder({
                 symbol,
                 orderHashes: hashes,
-                parentAddress: vault,
+                parentAddress,
             });
             if (!result.status)
                 return handleError(result.error);
@@ -18778,9 +19370,9 @@ function registerPositionCommands(program) {
         .option("--vault <address>", "Vault address")
         .action(async (opts) => {
         try {
-            const sdk = getSDK();
-            await ensureAuth(sdk);
-            const vault = opts.vault || sdk.address;
+            const vaultIndex = getGlobalVaultIndex(program);
+            const sdk = getSDK(vaultIndex);
+            const vault = opts.vault || resolveVaultAddress(vaultIndex) || sdk.address;
             const params = {
                 parentAddress: vault,
                 ...(opts.symbol ? { symbol: opts.symbol } : {}),
@@ -18823,7 +19415,7 @@ function registerPositionCommands(program) {
         .action(async (symbol, opts) => {
         try {
             const sdk = getSDK();
-            await ensureAuth(sdk);
+            symbol = normalizeSymbol(symbol);
             const perpId = await sdk.getPerpetualID(symbol);
             if (!perpId)
                 return handleError(`PerpetualID not found for ${symbol}`);
@@ -18872,7 +19464,8 @@ function registerPositionCommands(program) {
         .argument("<amount>", "Amount in USDC")
         .action(async (symbol, amount) => {
         try {
-            const sdk = getSDK();
+            const vaultIndex = getGlobalVaultIndex(program);
+            const sdk = getOnChainSDK(vaultIndex);
             const tx = await sdk.addMargin({ symbol, amount: Number(amount) });
             if (isJson(program))
                 return printJson({ digest: tx?.digest, status: "ok" });
@@ -18889,7 +19482,8 @@ function registerPositionCommands(program) {
         .argument("<amount>", "Amount in USDC")
         .action(async (symbol, amount) => {
         try {
-            const sdk = getSDK();
+            const vaultIndex = getGlobalVaultIndex(program);
+            const sdk = getOnChainSDK(vaultIndex);
             const tx = await sdk.removeMargin({ symbol, amount: Number(amount) });
             if (isJson(program))
                 return printJson({ digest: tx?.digest, status: "ok" });
@@ -18926,6 +19520,7 @@ function registerMarketCommands(program) {
         .argument("<symbol>", "Trading pair")
         .action(async (symbol) => {
         try {
+            symbol = normalizeSymbol(symbol);
             const sdk = getSDK();
             const result = await sdk.getTicker(symbol);
             if (!result.status || !result.data)
@@ -18954,6 +19549,7 @@ function registerMarketCommands(program) {
         .argument("<symbol>", "Trading pair")
         .action(async (symbol) => {
         try {
+            symbol = normalizeSymbol(symbol);
             const sdk = getSDK();
             const result = await sdk.getOrderBook(symbol);
             if (!result.status || !result.data)
@@ -18981,6 +19577,7 @@ function registerMarketCommands(program) {
         .argument("<symbol>", "Trading pair")
         .action(async (symbol) => {
         try {
+            symbol = normalizeSymbol(symbol);
             const sdk = getSDK();
             const result = await sdk.getOraclePrice(symbol);
             if (!result.status)
@@ -19004,16 +19601,20 @@ function registerHistoryCommands(program) {
         .option("--page <n>", "Page number", "1")
         .option("--size <n>", "Page size", "20")
         .option("--vault <address>", "Vault address")
+        .option("--begin-time <ms>", "Begin time filter (epoch ms)")
+        .option("--end-time <ms>", "End time filter (epoch ms)")
         .action(async (opts) => {
         try {
-            const sdk = getSDK();
-            await ensureAuth(sdk);
-            const vault = opts.vault || sdk.address;
+            const vaultIndex = getGlobalVaultIndex(program);
+            const sdk = getSDK(vaultIndex);
+            const vault = opts.vault || resolveVaultAddress(vaultIndex) || sdk.address;
             const result = await sdk.getHistoryOrders({
                 ...(opts.symbol ? { symbol: opts.symbol } : {}),
                 page: Number(opts.page),
                 pageSize: Number(opts.size),
                 parentAddress: vault,
+                ...(opts.beginTime ? { beginTime: Number(opts.beginTime) } : {}),
+                ...(opts.endTime ? { endTime: Number(opts.endTime) } : {}),
             });
             if (!result.status)
                 return handleError(result.error);
@@ -19043,16 +19644,18 @@ function registerHistoryCommands(program) {
         .option("--page <n>", "Page number", "1")
         .option("--size <n>", "Page size", "20")
         .option("--vault <address>", "Vault address")
+        .option("--begin-time <ms>", "Begin time filter (epoch ms)")
         .action(async (opts) => {
         try {
-            const sdk = getSDK();
-            await ensureAuth(sdk);
-            const vault = opts.vault || sdk.address;
+            const vaultIndex = getGlobalVaultIndex(program);
+            const sdk = getSDK(vaultIndex);
+            const vault = opts.vault || resolveVaultAddress(vaultIndex) || sdk.address;
             const result = await sdk.getFundingSettlements({
                 ...(opts.symbol ? { symbol: opts.symbol } : {}),
                 page: Number(opts.page),
                 pageSize: Number(opts.size),
                 parentAddress: vault,
+                ...(opts.beginTime ? { beginTime: Number(opts.beginTime) } : {}),
             });
             if (!result.status)
                 return handleError(result.error);
@@ -19060,12 +19663,13 @@ function registerHistoryCommands(program) {
                 return printJson(result.data);
             if (!result.data?.data?.length)
                 return console.log("No funding settlements.");
-            printTable(["Symbol", "Rate", "Fee", "Qty", "Side", "Time"], result.data.data.map((f) => [
+            printTable(["Symbol", "Side", "Size", "Rate", "Settlement", "Price", "Time"], result.data.data.map((f) => [
                 f.symbol || "-",
+                f.positionIsLong === 1 ? "LONG" : f.positionIsLong === 0 ? "SHORT" : (f.side || "-"),
+                formatWei(f.size || f.quantity),
                 formatWei(f.fundingRate),
-                formatWei(f.fundingFee),
-                formatWei(f.quantity),
-                f.side || "-",
+                formatWei(f.settlementAmount || f.fundingFee),
+                formatWei(f.oraclePrice),
                 f.createdAt ? new Date(f.createdAt).toLocaleString() : "-",
             ]));
         }
@@ -19079,15 +19683,17 @@ function registerHistoryCommands(program) {
         .option("--page <n>", "Page number", "1")
         .option("--size <n>", "Page size", "20")
         .option("--vault <address>", "Vault address")
+        .option("--begin-time <ms>", "Begin time filter (epoch ms)")
         .action(async (opts) => {
         try {
-            const sdk = getSDK();
-            await ensureAuth(sdk);
-            const vault = opts.vault || sdk.address;
+            const vaultIndex = getGlobalVaultIndex(program);
+            const sdk = getSDK(vaultIndex);
+            const vault = opts.vault || resolveVaultAddress(vaultIndex) || sdk.address;
             const result = await sdk.getBalanceChanges({
                 page: Number(opts.page),
                 pageSize: Number(opts.size),
                 parentAddress: vault,
+                ...(opts.beginTime ? { beginTime: Number(opts.beginTime) } : {}),
             });
             if (!result.status)
                 return handleError(result.error);
@@ -19095,12 +19701,11 @@ function registerHistoryCommands(program) {
                 return printJson(result.data);
             if (!result.data?.data?.length)
                 return console.log("No balance changes.");
-            printTable(["Type", "Amount", "Balance", "Symbol", "Time"], result.data.data.map((b) => [
-                b.type || "-",
-                formatWei(b.amount),
-                formatWei(b.balance),
-                b.symbol || "-",
-                b.createdAt ? new Date(b.createdAt).toLocaleString() : "-",
+            printTable(["Type", "Amount", "TxDigest", "Time"], result.data.data.map((b) => [
+                b.bizTypeDesc || b.type || "-",
+                formatWei(b.settlementAmount || b.amount),
+                b.txDigest ? b.txDigest.slice(0, 16) + "..." : "-",
+                (b.createdTime || b.createdAt) ? new Date(b.createdTime || b.createdAt).toLocaleString() : "-",
             ]));
         }
         catch (e) {
@@ -19109,55 +19714,338 @@ function registerHistoryCommands(program) {
     });
 }
 
+const USDC_DECIMALS = 6;
+/**
+ * Format a USDC atomic value (6 decimals) to human-readable.
+ */
+function formatUsdc(value) {
+    if (value === undefined || value === null || value === "")
+        return "0";
+    const bn = new BigNumber__default["default"](String(value));
+    if (bn.isNaN())
+        return "0";
+    return bn.dividedBy(new BigNumber__default["default"](10).pow(USDC_DECIMALS)).toFixed(USDC_DECIMALS);
+}
+/**
+ * Format a ratio (9-decimal, where 10^9 = 100%) to percentage string.
+ */
+function formatRatio(value) {
+    if (value === undefined || value === null || value === "")
+        return "0%";
+    const bn = new BigNumber__default["default"](String(value));
+    if (bn.isNaN())
+        return "0%";
+    return bn.dividedBy(new BigNumber__default["default"](10).pow(7)).toFixed(2) + "%";
+}
+/**
+ * Convert percentage to 9-decimal ratio string.
+ * E.g., "10" (10%) -> "100000000" (10 * 10^7)
+ */
+function percentToRatio(pct) {
+    const val = parseFloat(pct);
+    if (isNaN(val) || val < 0)
+        throw new Error(`Invalid percentage: ${pct}`);
+    return new BigNumber__default["default"](val).multipliedBy(new BigNumber__default["default"](10).pow(7)).toFixed(0);
+}
 function registerVaultCommands(program) {
-    const vault = program.command("vault").description("Vault / sub-account operations");
+    const vault = program.command("vault").description("On-chain vault operations");
+    // === vault create ===
     vault
-        .command("set-sub-account")
-        .description("Set sub-account on-chain (authorize a sub-account address)")
-        .argument("<subAddress>", "Sub-account address to authorize")
-        .action(async (subAddress) => {
+        .command("create")
+        .description("Create a new on-chain vault")
+        .requiredOption("--name <name>", "Vault display name")
+        .requiredOption("--trader <address>", "Trader address")
+        .requiredOption("--max-cap <usdc>", "Maximum USDC cap")
+        .requiredOption("--min-deposit <usdc>", "Minimum deposit amount in USDC")
+        .requiredOption("--creator-share <pct>", "Creator minimum share ratio (%)")
+        .requiredOption("--profit-share <pct>", "Creator profit share ratio (%)")
+        .requiredOption("--initial <usdc>", "Initial deposit in USDC")
+        .action(async (opts) => {
         try {
             const sdk = getSDK();
-            const tx = await sdk.setSubAccount(subAddress);
+            console.log(`Creating vault "${opts.name}"...`);
+            const tx = await sdk.createVault({
+                name: opts.name,
+                trader: opts.trader,
+                maxCap: Number(opts.maxCap),
+                minDepositAmount: Number(opts.minDeposit),
+                creatorMinimumShareRatio: percentToRatio(opts.creatorShare),
+                creatorProfitShareRatio: percentToRatio(opts.profitShare),
+                initialAmount: Number(opts.initial),
+            });
+            printTxResult(program, tx, `Vault "${opts.name}" created.`);
+        }
+        catch (e) {
+            handleError(e);
+        }
+    });
+    // === vault list ===
+    vault
+        .command("list")
+        .description("List vaults created by current wallet")
+        .action(async () => {
+        try {
+            const sdk = getSDK();
+            const result = await sdk.listVaults();
+            if (!result.status)
+                return handleError(result.error);
             if (isJson(program))
-                return printJson({ digest: tx?.digest, status: "ok" });
-            console.log(`Sub-account ${subAddress} set. Tx: ${tx?.digest || JSON.stringify(tx)}`);
+                return printJson(result.data);
+            if (!result.data?.length)
+                return console.log("No vaults found.");
+            printTable(["Vault ID", "Name", "Trader", "Deposit", "Status"], result.data.map((v) => [
+                v.vaultId,
+                v.name || "-",
+                v.trader,
+                v.depositStatus === 1 ? "Open" : "Closed",
+                v.closedAt > 0 ? "Closed" : "Active",
+            ]));
         }
         catch (e) {
             handleError(e);
         }
     });
+    // === vault info ===
     vault
         .command("info")
-        .description("Show vault account info")
-        .option("--address <address>", "Vault address (or use VAULT_ADDRESS env)")
-        .action(async (opts) => {
+        .description("Show vault details (e.g. vault info <vaultId>)")
+        .argument("<vaultId>", "Vault object ID")
+        .action(async (vaultId) => {
         try {
             const sdk = getSDK();
-            await ensureAuth(sdk);
-            const vaultAddr = getVaultAddress(opts.address);
-            if (!vaultAddr)
-                return handleError("Vault address required (--address or VAULT_ADDRESS env)");
-            const result = await sdk.getAccountInfo({ parentAddress: vaultAddr });
+            const result = await sdk.getVaultInfo(vaultId);
             if (!result.status || !result.data)
                 return handleError(result.error);
             if (isJson(program))
                 return printJson(result.data);
             const d = result.data;
             printTable(["Field", "Value"], [
-                ["Vault Address", vaultAddr],
-                ["Wallet Balance", formatWei(d.walletBalance)],
-                ["Account Value", formatWei(d.accountValue)],
-                ["Free Collateral", formatWei(d.freeCollateral)],
-                ["Total Margin", formatWei(d.totalMargin)],
-                ["Unrealized PnL", formatWei(d.totalUnrealizedProfit)],
+                ["Vault ID", vaultId],
+                ["Name", d.name || "-"],
+                ["Creator", d.creator || "-"],
+                ["Trader", d.trader || "-"],
+                ["Deposit Status", d.deposit_status === true || d.deposit_status === "true" ? "Open" : "Closed"],
+                ["Total Shares", formatUsdc(d.total_shares)],
+                ["Max Cap", formatUsdc(d.max_cap)],
+                ["Min Deposit", formatUsdc(d.min_deposit_amount)],
+                ["Creator Min Share Ratio", formatRatio(d.creator_minimum_share_ratio)],
+                ["Creator Profit Share Ratio", formatRatio(d.creator_profit_share_ratio)],
+                ["Auto Close on Withdraw", String(d.auto_close_on_withdraw ?? "-")],
             ]);
         }
         catch (e) {
             handleError(e);
         }
     });
+    // === vault deposit ===
+    vault
+        .command("deposit")
+        .description("Deposit USDC into a vault (e.g. vault deposit <vaultId> <amount>)")
+        .argument("<vaultId>", "Vault object ID")
+        .argument("<amount>", "USDC amount to deposit")
+        .action(async (vaultId, amount) => {
+        try {
+            const sdk = getSDK();
+            console.log(`Depositing ${amount} USDC to vault ${vaultId}...`);
+            const tx = await sdk.depositToVault({ vaultID: vaultId, amount: Number(amount) });
+            printTxResult(program, tx, `Deposited ${amount} USDC.`);
+        }
+        catch (e) {
+            handleError(e);
+        }
+    });
+    // === vault withdraw ===
+    vault
+        .command("withdraw")
+        .description("Request withdrawal from vault (e.g. vault withdraw <vaultId> <shares>)")
+        .argument("<vaultId>", "Vault object ID")
+        .argument("<shares>", "Number of shares to withdraw")
+        .action(async (vaultId, shares) => {
+        try {
+            const sdk = getSDK();
+            console.log(`Requesting withdrawal of ${shares} shares from vault ${vaultId}...`);
+            const tx = await sdk.requestWithdrawFromVault({ vaultID: vaultId, shares: Number(shares) });
+            printTxResult(program, tx, `Withdrawal request submitted for ${shares} shares.`);
+        }
+        catch (e) {
+            handleError(e);
+        }
+    });
+    // === vault fill ===
+    vault
+        .command("fill")
+        .description("Fill pending withdrawal requests (e.g. vault fill <vaultId> <requestIDs...>)")
+        .argument("<vaultId>", "Vault object ID")
+        .argument("<requestIDs...>", "Withdrawal request object IDs")
+        .option("--markets <ids>", "Comma-separated market PerpetualIDs for share price update")
+        .action(async (vaultId, requestIDs, opts) => {
+        try {
+            const sdk = getSDK();
+            const markets = opts.markets ? opts.markets.split(",") : undefined;
+            console.log(`Filling ${requestIDs.length} withdrawal request(s)...`);
+            const tx = await sdk.fillWithdrawalRequests({
+                vaultID: vaultId,
+                withdrawalRequestIDs: requestIDs,
+                markets,
+            });
+            printTxResult(program, tx, `Filled ${requestIDs.length} withdrawal request(s).`);
+        }
+        catch (e) {
+            handleError(e);
+        }
+    });
+    // === vault close ===
+    vault
+        .command("close")
+        .description("Close a vault (e.g. vault close <vaultId>)")
+        .argument("<vaultId>", "Vault object ID")
+        .option("--markets <ids>", "Comma-separated market PerpetualIDs")
+        .action(async (vaultId, opts) => {
+        try {
+            const sdk = getSDK();
+            const markets = opts.markets ? opts.markets.split(",") : undefined;
+            console.log(`Closing vault ${vaultId}...`);
+            const tx = await sdk.closeVault({ vaultID: vaultId, markets });
+            printTxResult(program, tx, "Vault closed.");
+        }
+        catch (e) {
+            handleError(e);
+        }
+    });
+    // === vault remove ===
+    vault
+        .command("remove")
+        .description("Remove a closed vault (e.g. vault remove <vaultId>)")
+        .argument("<vaultId>", "Vault object ID")
+        .action(async (vaultId) => {
+        try {
+            const sdk = getSDK();
+            console.log(`Removing vault ${vaultId}...`);
+            const tx = await sdk.removeVault({ vaultID: vaultId });
+            printTxResult(program, tx, "Vault removed.");
+        }
+        catch (e) {
+            handleError(e);
+        }
+    });
+    // === vault claim ===
+    vault
+        .command("claim")
+        .description("Claim funds from a closed vault (e.g. vault claim <vaultId>)")
+        .argument("<vaultId>", "Vault object ID")
+        .action(async (vaultId) => {
+        try {
+            const sdk = getSDK();
+            console.log(`Claiming funds from vault ${vaultId}...`);
+            const tx = await sdk.claimClosedVaultFunds({ vaultID: vaultId });
+            printTxResult(program, tx, "Funds claimed.");
+        }
+        catch (e) {
+            handleError(e);
+        }
+    });
+    // === vault set-trader ===
+    vault
+        .command("set-trader")
+        .description("Change the trader address (e.g. vault set-trader <vaultId> <address>)")
+        .argument("<vaultId>", "Vault object ID")
+        .argument("<address>", "New trader address")
+        .action(async (vaultId, address) => {
+        try {
+            const sdk = getSDK();
+            const tx = await sdk.setVaultTrader({ vaultID: vaultId, newTrader: address });
+            printTxResult(program, tx, `Trader set to ${address}.`);
+        }
+        catch (e) {
+            handleError(e);
+        }
+    });
+    // === vault set-sub-trader ===
+    vault
+        .command("set-sub-trader")
+        .description("Add or remove a sub-trader (e.g. vault set-sub-trader <vaultId> <address>)")
+        .argument("<vaultId>", "Vault object ID")
+        .argument("<address>", "Sub-trader address")
+        .option("--disable", "Remove sub-trader (default: add)")
+        .action(async (vaultId, address, opts) => {
+        try {
+            const sdk = getSDK();
+            const status = !opts.disable;
+            const tx = await sdk.setVaultSubTrader({ vaultID: vaultId, subTrader: address, status });
+            printTxResult(program, tx, `Sub-trader ${address} ${status ? "added" : "removed"}.`);
+        }
+        catch (e) {
+            handleError(e);
+        }
+    });
+    // === vault set-deposit-status ===
+    vault
+        .command("set-deposit-status")
+        .description("Enable or disable deposits (e.g. vault set-deposit-status <vaultId>)")
+        .argument("<vaultId>", "Vault object ID")
+        .option("--disable", "Disable deposits (default: enable)")
+        .action(async (vaultId, opts) => {
+        try {
+            const sdk = getSDK();
+            const status = !opts.disable;
+            const tx = await sdk.setVaultDepositStatus({ vaultID: vaultId, status });
+            printTxResult(program, tx, `Deposits ${status ? "enabled" : "disabled"}.`);
+        }
+        catch (e) {
+            handleError(e);
+        }
+    });
+    // === vault set-max-cap ===
+    vault
+        .command("set-max-cap")
+        .description("Set maximum USDC cap (e.g. vault set-max-cap <vaultId> <amount>)")
+        .argument("<vaultId>", "Vault object ID")
+        .argument("<amount>", "Max cap in USDC")
+        .action(async (vaultId, amount) => {
+        try {
+            const sdk = getSDK();
+            const tx = await sdk.setVaultMaxCap({ vaultID: vaultId, maxCap: Number(amount) });
+            printTxResult(program, tx, `Max cap set to ${amount} USDC.`);
+        }
+        catch (e) {
+            handleError(e);
+        }
+    });
+    // === vault set-min-deposit ===
+    vault
+        .command("set-min-deposit")
+        .description("Set minimum deposit amount (e.g. vault set-min-deposit <vaultId> <amount>)")
+        .argument("<vaultId>", "Vault object ID")
+        .argument("<amount>", "Min deposit in USDC")
+        .action(async (vaultId, amount) => {
+        try {
+            const sdk = getSDK();
+            const tx = await sdk.setVaultMinDepositAmount({ vaultID: vaultId, minDepositAmount: Number(amount) });
+            printTxResult(program, tx, `Min deposit set to ${amount} USDC.`);
+        }
+        catch (e) {
+            handleError(e);
+        }
+    });
+    // === vault set-auto-close ===
+    vault
+        .command("set-auto-close")
+        .description("Enable or disable auto-close on withdrawal (e.g. vault set-auto-close <vaultId>)")
+        .argument("<vaultId>", "Vault object ID")
+        .option("--disable", "Disable auto-close (default: enable)")
+        .action(async (vaultId, opts) => {
+        try {
+            const sdk = getSDK();
+            const enabled = !opts.disable;
+            const tx = await sdk.setVaultAutoCloseOnWithdraw({ vaultID: vaultId, autoCloseOnWithdraw: enabled });
+            printTxResult(program, tx, `Auto-close on withdraw ${enabled ? "enabled" : "disabled"}.`);
+        }
+        catch (e) {
+            handleError(e);
+        }
+    });
 }
+
 function registerOrdersCommand(program) {
     program
         .command("orders")
@@ -19166,9 +20054,9 @@ function registerOrdersCommand(program) {
         .option("--vault <address>", "Vault address")
         .action(async (opts) => {
         try {
-            const sdk = getSDK();
-            await ensureAuth(sdk);
-            const vault = opts.vault || sdk.address;
+            const vaultIndex = getGlobalVaultIndex(program);
+            const sdk = getSDK(vaultIndex);
+            const vault = opts.vault || resolveVaultAddress(vaultIndex) || sdk.address;
             const params = {
                 parentAddress: vault,
                 ...(opts.symbol ? { symbol: opts.symbol } : {}),
@@ -19197,6 +20085,71 @@ function registerOrdersCommand(program) {
     });
 }
 
+function registerSubAccountCommands(program) {
+    const sub = program.command("sub-account").description("HD-derived sub-account operations");
+    sub
+        .command("set")
+        .description("Set sub-account on-chain (authorize a sub-account address)")
+        .argument("<subAddress>", "Sub-account address to authorize")
+        .action(async (subAddress) => {
+        try {
+            const sdk = getSDK();
+            const tx = await sdk.setSubAccount(subAddress);
+            if (isJson(program))
+                return printJson({ digest: tx?.digest, status: "ok" });
+            console.log(`Sub-account ${subAddress} set. Tx: ${tx?.digest || JSON.stringify(tx)}`);
+        }
+        catch (e) {
+            handleError(e);
+        }
+    });
+    sub
+        .command("setup")
+        .description("Derive sub-account at index and register it on-chain via main account")
+        .argument("<index>", "Vault index to setup (1+)")
+        .action(async (indexStr) => {
+        try {
+            const index = Number(indexStr);
+            if (isNaN(index) || index < 1)
+                return handleError("Vault index must be >= 1");
+            const subAddress = resolveVaultAddress(index);
+            if (!subAddress)
+                return handleError("Could not derive vault address. Is MNEMONIC set?");
+            const sdk = getSDK();
+            console.log(`Registering sub-account ${index} (${subAddress})...`);
+            const tx = await sdk.setSubAccount(subAddress);
+            if (isJson(program))
+                return printJson({ digest: tx?.digest, index, address: subAddress });
+            console.log(`Sub-account ${index} setup complete. Address: ${subAddress}`);
+            console.log(`Tx: ${tx?.digest || JSON.stringify(tx)}`);
+        }
+        catch (e) {
+            handleError(e);
+        }
+    });
+    sub
+        .command("list")
+        .description("List HD-derived sub-account addresses")
+        .option("--count <n>", "Number of addresses to derive", "5")
+        .action(async (opts) => {
+        try {
+            const count = Number(opts.count) || 5;
+            const addresses = listVaultAddresses(count);
+            if (isJson(program))
+                return printJson(addresses);
+            printTable(["Index", "Address", "Path", "Role"], addresses.map((a) => [
+                String(a.index),
+                a.address,
+                a.path,
+                a.index === 0 ? "Main Account" : `Sub-Account ${a.index}`,
+            ]));
+        }
+        catch (e) {
+            handleError(e);
+        }
+    });
+}
+
 function formatCoinBalance(totalBalance, decimals) {
     const bn = new BigNumber__default["default"](totalBalance);
     if (bn.isNaN() || bn.isZero())
@@ -19209,14 +20162,18 @@ function registerBalanceCommand(program) {
         .description("Show on-chain coin balances for the current wallet")
         .action(async () => {
         try {
-            const sdk = getSDK();
-            const result = await sdk.getAllBalances();
+            const vaultIndex = getGlobalVaultIndex(program);
+            const sdk = getSDK(vaultIndex);
+            const vaultAddr = resolveVaultAddress(vaultIndex);
+            const result = await sdk.getAllBalances(vaultAddr);
             if (!result.status || !result.data)
                 return handleError(result.error);
             if (isJson(program))
                 return printJson(result.data);
             if (!result.data.length)
                 return console.log("No coins found.");
+            if (vaultAddr)
+                console.log(`Balances for vault: ${vaultAddr}`);
             const rows = [];
             for (const b of result.data) {
                 const meta = await sdk.getCoinMetadata(b.coinType);
@@ -19234,19 +20191,24 @@ function registerBalanceCommand(program) {
 
 const program = new commander.Command();
 program
-    .name("dipcoin")
+    .name("dipcoin-cli")
     .description("DipCoin Perpetual Trading CLI")
     .version("0.5.0")
-    .option("--json", "Output in JSON format");
+    .option("--json", "Output in JSON format")
+    .option("--vault-index <n>", "Vault index (1+ for HD-derived sub-accounts)");
 registerAccountCommands(program);
 registerTradeCommands(program);
 registerPositionCommands(program);
 registerMarketCommands(program);
 registerHistoryCommands(program);
 registerVaultCommands(program);
+registerSubAccountCommands(program);
 registerOrdersCommand(program);
 registerBalanceCommand(program);
 program.parseAsync(process.argv).catch((err) => {
     console.error("Error:", err.message || err);
     process.exit(1);
 });
+
+exports.getGlobalVaultIndex = getGlobalVaultIndex;
+//# sourceMappingURL=cli.cjs.map