dipcoin-cli 1.3.3 → 1.3.5

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}`));
@@ -16653,21 +16655,45 @@ function buildAddMarginTx(deployment, args, tx, gasBudget, sender) {
     if (sender)
         t.setSender(sender);
     const packageId = getPackageId(deployment);
-    t.moveCall({
-        target: `${packageId}::exchange::add_margin_v3`,
-        arguments: [
-            t.object(getProtocolConfigId(deployment)),
-            t.object(CLOCK_OBJECT_ID),
-            t.object(args.perpID || getPerpetualId(deployment, args.market)),
-            t.object(getBankId(deployment)),
-            t.object(args.subAccountsMapID || getSubAccountsId(deployment)),
-            t.object(getTxIndexerId(deployment)),
-            t.object(getPriceFeedId(deployment)),
-            t.pure.address(args.account || sender || ""),
-            t.pure.u128(args.amount.toString()),
-        ],
-        typeArguments: [getCurrencyType(deployment)],
-    });
+    const signed = args.signedPayload;
+    if (signed) {
+        t.moveCall({
+            target: `${packageId}::exchange::add_margin_v4`,
+            arguments: [
+                t.object(getProtocolConfigId(deployment)),
+                t.object(CLOCK_OBJECT_ID),
+                t.object(args.perpID || getPerpetualId(deployment, args.market)),
+                t.object(getBankId(deployment)),
+                t.object(args.subAccountsMapID || getSubAccountsId(deployment)),
+                t.object(getTxIndexerId(deployment)),
+                t.object(getPriceFeedId(deployment)),
+                t.pure.vector("u8", signed.userAddress),
+                t.pure.u128(args.amount.toString()),
+                t.pure.u128(signed.salt.toString()),
+                t.pure.u64(signed.expiration.toString()),
+                t.pure.vector("u8", signed.signature),
+                t.pure.vector("u8", signed.publicKey),
+            ],
+            typeArguments: [getCurrencyType(deployment)],
+        });
+    }
+    else {
+        t.moveCall({
+            target: `${packageId}::exchange::add_margin_v3`,
+            arguments: [
+                t.object(getProtocolConfigId(deployment)),
+                t.object(CLOCK_OBJECT_ID),
+                t.object(args.perpID || getPerpetualId(deployment, args.market)),
+                t.object(getBankId(deployment)),
+                t.object(args.subAccountsMapID || getSubAccountsId(deployment)),
+                t.object(getTxIndexerId(deployment)),
+                t.object(getPriceFeedId(deployment)),
+                t.pure.address(args.account || sender || ""),
+                t.pure.u128(args.amount.toString()),
+            ],
+            typeArguments: [getCurrencyType(deployment)],
+        });
+    }
     return t;
 }
 function buildRemoveMarginTx(deployment, args, tx, gasBudget, sender) {
@@ -16677,21 +16703,45 @@ function buildRemoveMarginTx(deployment, args, tx, gasBudget, sender) {
     if (sender)
         t.setSender(sender);
     const packageId = getPackageId(deployment);
-    t.moveCall({
-        target: `${packageId}::exchange::remove_margin_v3`,
-        arguments: [
-            t.object(getProtocolConfigId(deployment)),
-            t.object(CLOCK_OBJECT_ID),
-            t.object(args.perpID || getPerpetualId(deployment, args.market)),
-            t.object(getBankId(deployment)),
-            t.object(args.subAccountsMapID || getSubAccountsId(deployment)),
-            t.object(getTxIndexerId(deployment)),
-            t.object(getPriceFeedId(deployment)),
-            t.pure.address(args.account || sender || ""),
-            t.pure.u128(args.amount.toString()),
-        ],
-        typeArguments: [getCurrencyType(deployment)],
-    });
+    const signed = args.signedPayload;
+    if (signed) {
+        t.moveCall({
+            target: `${packageId}::exchange::remove_margin_v4`,
+            arguments: [
+                t.object(getProtocolConfigId(deployment)),
+                t.object(CLOCK_OBJECT_ID),
+                t.object(args.perpID || getPerpetualId(deployment, args.market)),
+                t.object(getBankId(deployment)),
+                t.object(args.subAccountsMapID || getSubAccountsId(deployment)),
+                t.object(getTxIndexerId(deployment)),
+                t.object(getPriceFeedId(deployment)),
+                t.pure.vector("u8", signed.userAddress),
+                t.pure.u128(args.amount.toString()),
+                t.pure.u128(signed.salt.toString()),
+                t.pure.u64(signed.expiration.toString()),
+                t.pure.vector("u8", signed.signature),
+                t.pure.vector("u8", signed.publicKey),
+            ],
+            typeArguments: [getCurrencyType(deployment)],
+        });
+    }
+    else {
+        t.moveCall({
+            target: `${packageId}::exchange::remove_margin_v3`,
+            arguments: [
+                t.object(getProtocolConfigId(deployment)),
+                t.object(CLOCK_OBJECT_ID),
+                t.object(args.perpID || getPerpetualId(deployment, args.market)),
+                t.object(getBankId(deployment)),
+                t.object(args.subAccountsMapID || getSubAccountsId(deployment)),
+                t.object(getTxIndexerId(deployment)),
+                t.object(getPriceFeedId(deployment)),
+                t.pure.address(args.account || sender || ""),
+                t.pure.u128(args.amount.toString()),
+            ],
+            typeArguments: [getCurrencyType(deployment)],
+        });
+    }
     return t;
 }
 function buildWithdrawTx(deployment, args, tx, gasBudget, sender) {
@@ -16758,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) {
@@ -16777,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));
@@ -17736,9 +17857,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) {
@@ -18307,12 +18426,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,
@@ -18665,7 +18780,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`);
         }
@@ -18688,6 +18803,130 @@ class DipCoinPerpSDK {
             txHash,
         };
     }
+    packPayload(fields) {
+        let result = "{\n";
+        for (const [key, value] of fields) {
+            result += `"${key}":"${value}",\n`;
+        }
+        result += '"domain":"dipcoin.io"\n';
+        result += "}";
+        return result;
+    }
+    normalizeSuiAddress(address) {
+        const hex = address.startsWith("0x") ? address.slice(2) : address;
+        if (!/^[0-9a-fA-F]+$/.test(hex) || hex.length > 64) {
+            throw new Error(`Invalid Sui address: ${address}`);
+        }
+        return `0x${hex.toLowerCase().padStart(64, "0")}`;
+    }
+    toUnifiedSuiAddress(address) {
+        const normalized = this.normalizeSuiAddress(address);
+        return `Sui:0x${normalized.slice(2)}`;
+    }
+    toUnifiedSuiAddressBytes(address) {
+        const normalized = this.normalizeSuiAddress(address);
+        return [0, ...Array.from(Buffer.from(normalized.slice(2), "hex"))];
+    }
+    async signDipcoinActionPayload(fields, addressForVector) {
+        const salt = Date.now();
+        const expiration = salt + 1_800_000;
+        const message = this.packPayload([
+            ...fields,
+            ["salt", String(salt)],
+            ["expiration", String(expiration)],
+        ]);
+        const signed = await this.keypair.signPersonalMessage(new TextEncoder().encode(message));
+        const parsed = cryptography.parseSerializedSignature(typeof signed === "string" ? signed : signed.signature);
+        const scheme = String(parsed.signatureScheme);
+        const flag = /ed25519/i.test(scheme) ? 1 : 0;
+        if (!/ed25519|secp256k1|secp256r1/i.test(scheme)) {
+            throw new Error(`Unsupported signature scheme for signed payload: ${scheme}`);
+        }
+        return {
+            userAddress: this.toUnifiedSuiAddressBytes(addressForVector),
+            salt: String(salt),
+            expiration: String(expiration),
+            signature: [...Array.from(Buffer.from(parsed.signature)), flag],
+            publicKey: Array.from(Buffer.from(parsed.publicKey)),
+        };
+    }
+    async signUserAmountActionPayload(args) {
+        return this.signDipcoinActionPayload([
+            ["action", args.action],
+            ["market", this.normalizeSuiAddress(args.market)],
+            ["user", this.toUnifiedSuiAddress(args.user)],
+            ["amount", args.amount],
+        ], args.user);
+    }
+    async signVaultCreatePayload(args) {
+        return this.signDipcoinActionPayload([
+            ["action", "VaultCreate"],
+            ["creator", this.toUnifiedSuiAddress(args.creator)],
+            ["name", args.name],
+            ["trader", this.toUnifiedSuiAddress(args.trader)],
+            ["maxCap", args.maxCap],
+            ["minDepositAmount", args.minDepositAmount],
+            ["creatorMinimumShareRatio", args.creatorMinimumShareRatio],
+            ["creatorProfitShareRatio", args.creatorProfitShareRatio],
+            ["initialAmount", args.initialAmount],
+        ], args.creator);
+    }
+    async signVaultUserAmountPayload(action, vaultID, user, amount) {
+        return this.signDipcoinActionPayload([
+            ["action", action],
+            ["vault", this.normalizeSuiAddress(vaultID)],
+            ["user", this.toUnifiedSuiAddress(user)],
+            ["amount", amount],
+        ], user);
+    }
+    async signVaultUserPayload(action, vaultID, user) {
+        return this.signDipcoinActionPayload([
+            ["action", action],
+            ["vault", this.normalizeSuiAddress(vaultID)],
+            ["user", this.toUnifiedSuiAddress(user)],
+        ], user);
+    }
+    async signVaultSetTraderPayload(vaultID, creator, newTrader) {
+        return this.signDipcoinActionPayload([
+            ["action", "VaultSetTrader"],
+            ["vault", this.normalizeSuiAddress(vaultID)],
+            ["creator", this.toUnifiedSuiAddress(creator)],
+            ["newTrader", this.toUnifiedSuiAddress(newTrader)],
+        ], creator);
+    }
+    async signVaultSetSubTraderPayload(vaultID, trader, subTrader, status) {
+        return this.signDipcoinActionPayload([
+            ["action", "VaultSetSubTrader"],
+            ["vault", this.normalizeSuiAddress(vaultID)],
+            ["trader", this.toUnifiedSuiAddress(trader)],
+            ["subTrader", this.toUnifiedSuiAddress(subTrader)],
+            ["status", String(status)],
+        ], trader);
+    }
+    async signVaultDepositStatusPayload(vaultID, creator, status) {
+        return this.signDipcoinActionPayload([
+            ["action", "VaultSetDepositStatus"],
+            ["vault", this.normalizeSuiAddress(vaultID)],
+            ["creator", this.toUnifiedSuiAddress(creator)],
+            ["status", String(status)],
+        ], creator);
+    }
+    async signVaultCreatorAmountPayload(action, vaultID, creator, amount) {
+        return this.signDipcoinActionPayload([
+            ["action", action],
+            ["vault", this.normalizeSuiAddress(vaultID)],
+            ["creator", this.toUnifiedSuiAddress(creator)],
+            ["amount", amount],
+        ], creator);
+    }
+    async signVaultAutoClosePayload(vaultID, creator, autoCloseOnWithdraw) {
+        return this.signDipcoinActionPayload([
+            ["action", "VaultSetAutoCloseOnWithdraw"],
+            ["vault", this.normalizeSuiAddress(vaultID)],
+            ["creator", this.toUnifiedSuiAddress(creator)],
+            ["autoCloseOnWithdraw", String(autoCloseOnWithdraw)],
+        ], creator);
+    }
     getDeploymentProtocolConfigId() {
         const protocolId = this.deploymentConfig?.objects?.ProtocolConfig?.id;
         if (!protocolId) {
@@ -18697,6 +18936,17 @@ class DipCoinPerpSDK {
     }
     async buildMarginTransaction(params, action) {
         const payload = this.buildMarginCallArgs(params, action);
+        const signedMarket = payload.perpID ||
+            (payload.market ? this.resolvePerpIdFromDeployment(payload.market) : undefined);
+        if (!signedMarket) {
+            throw new Error("PerpetualID is required for signed margin payload");
+        }
+        const signedPayload = await this.signUserAmountActionPayload({
+            action: action === "add" ? "AddMargin" : "RemoveMargin",
+            market: signedMarket,
+            user: payload.account,
+            amount: payload.amount,
+        });
         // v6+ requires PriceFeed to be fresh (~60s) before the margin call. Operator updates
         // are only hourly so we always fetch + prepend our own update_price_feed step.
         const sym = payload.market || params.symbol;
@@ -18706,9 +18956,9 @@ class DipCoinPerpSDK {
         const baseTx = new transactions.Transaction();
         this.appendPriceFeedUpdates(baseTx, Array.from(feeds.values()));
         if (action === "add") {
-            return buildAddMarginTx(this.deploymentConfig, payload, baseTx, params.gasBudget);
+            return buildAddMarginTx(this.deploymentConfig, { ...payload, signedPayload }, baseTx, params.gasBudget);
         }
-        return buildRemoveMarginTx(this.deploymentConfig, payload, baseTx, params.gasBudget);
+        return buildRemoveMarginTx(this.deploymentConfig, { ...payload, signedPayload }, baseTx, params.gasBudget);
     }
     async buildUpdatePriceTransaction(symbol) {
         if (!symbol) {
@@ -18924,7 +19174,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) };
@@ -18997,6 +19250,107 @@ class DipCoinPerpSDK {
         }
         return id;
     }
+    sleep(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    }
+    getSignedPriceFeedTimestamps(payload) {
+        let offset = 0;
+        let length = 0;
+        let shift = 0;
+        while (offset < payload.length) {
+            const byte = payload[offset++];
+            length |= (byte & 0x7f) << shift;
+            if ((byte & 0x80) === 0)
+                break;
+            shift += 7;
+        }
+        if (length <= 0)
+            return [];
+        const timestamps = [];
+        for (let i = 0; i < length; i++) {
+            const timestampOffset = offset + 32 + 16;
+            if (timestampOffset + 8 > payload.length)
+                return [];
+            const view = new DataView(payload.buffer, payload.byteOffset + timestampOffset, 8);
+            timestamps.push(Number(view.getBigUint64(0, true)));
+            offset = timestampOffset + 8 + 2;
+        }
+        return timestamps;
+    }
+    getSignedPriceFeedMaxTimestamp(payload) {
+        const timestamps = this.getSignedPriceFeedTimestamps(payload);
+        return timestamps.length ? Math.max(...timestamps) : undefined;
+    }
+    async waitForSignedPriceFeedClock(payload) {
+        const timestamp = this.getSignedPriceFeedMaxTimestamp(payload);
+        if (!timestamp)
+            return;
+        // price_feed::collect_price_updates accepts timestamps no more than 1500ms
+        // ahead of Sui Clock and no more than 60000ms behind it. The DipCoin API can
+        // sign with wall-clock time while Sui Clock lags, so wait for the chain clock
+        // 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();
+        const deadline = start + 180_000;
+        while (Date.now() <= deadline) {
+            const clock = await this.suiClient.getObject({
+                id: "0x6",
+                options: { showContent: true },
+            });
+            const clockMs = Number(clock.data?.content?.fields?.timestamp_ms);
+            if (!Number.isFinite(clockMs))
+                return;
+            const waitMs = timestamp - clockMs + 10_000;
+            if (waitMs <= 0)
+                return;
+            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));
+        }
+    }
+    async waitForSignedPriceFeedEntries(entries) {
+        const timestamps = entries.flatMap((entry) => this.getSignedPriceFeedTimestamps(entry.payload));
+        if (!timestamps.length)
+            return;
+        const maxTimestamp = Math.max(...timestamps);
+        const minTimestamp = Math.min(...timestamps);
+        const start = Date.now();
+        const deadline = start + 180_000;
+        while (Date.now() <= deadline) {
+            const clock = await this.suiClient.getObject({
+                id: "0x6",
+                options: { showContent: true },
+            });
+            const clockMs = Number(clock.data?.content?.fields?.timestamp_ms);
+            if (!Number.isFinite(clockMs))
+                return;
+            const waitMs = maxTimestamp - clockMs + 10_000;
+            if (waitMs <= 0) {
+                if (clockMs - minTimestamp > 55_000) {
+                    throw new Error("Signed price feed expired while waiting for Sui Clock");
+                }
+                return;
+            }
+            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));
+        }
+    }
+    async requestSignedPriceFeedEntry(symbols) {
+        const qs = symbols.map((s) => `symbols=${encodeURIComponent(s)}`).join("&");
+        const resp = await this.httpClient.get(`${API_ENDPOINTS.SIGNED_PRICE_LATEST}?${qs}`);
+        if (resp.code !== 200 || !resp.data) {
+            throw new Error(`Failed to fetch signed price feed for [${symbols.join(",")}]: ${resp.message || `code ${resp.code}`}`);
+        }
+        const d = resp.data;
+        const b64 = (s) => Uint8Array.from(Buffer.from(s, "base64"));
+        if (!d.payload || !d.signature || !d.publicKey) {
+            throw new Error("Signed price feed response missing payload/signature/publicKey");
+        }
+        return { payload: b64(d.payload), signature: b64(d.signature), publicKey: b64(d.publicKey) };
+    }
     /**
      * Fetch signed price update bytes for the given markets from the DipCoin pricing service.
      * Each entry's payload/signature/publicKey is consumed by
@@ -19010,22 +19364,72 @@ class DipCoinPerpSDK {
         const out = new Map();
         if (symbols.length === 0)
             return out;
-        const qs = symbols.map((s) => `symbols=${encodeURIComponent(s)}`).join("&");
-        const resp = await this.httpClient.get(`${API_ENDPOINTS.SIGNED_PRICE_LATEST}?${qs}`);
-        if (resp.code !== 200 || !resp.data) {
-            throw new Error(`Failed to fetch signed price feed for [${symbols.join(",")}]: ${resp.message || `code ${resp.code}`}`);
+        let lastClockError;
+        for (let attempt = 0; attempt < 5; attempt++) {
+            const entry = await this.requestSignedPriceFeedEntry(symbols);
+            try {
+                await this.waitForSignedPriceFeedEntries([entry]);
+            }
+            catch (error) {
+                const message = String(error?.message || error);
+                if (!message.includes("too far ahead") && !message.includes("expired")) {
+                    throw error;
+                }
+                lastClockError = error;
+                await this.sleep(2_000 * (attempt + 1));
+                continue;
+            }
+            // API returns a single bundle covering all requested symbols' prices in priceList,
+            // but only one (payload, signature, publicKey) tuple. Map every requested symbol to it.
+            for (const sym of symbols)
+                out.set(sym, entry);
+            return out;
         }
-        const d = resp.data;
-        const b64 = (s) => Uint8Array.from(Buffer.from(s, "base64"));
-        if (!d.payload || !d.signature || !d.publicKey) {
-            throw new Error("Signed price feed response missing payload/signature/publicKey");
+        throw lastClockError || new Error("Failed to fetch a usable signed price feed");
+    }
+    async fetchSignedPriceFeedChunks(symbols, chunkSize = 20) {
+        if (symbols.length === 0)
+            return [];
+        let lastClockError;
+        for (let attempt = 0; attempt < 5; attempt++) {
+            const entries = [];
+            for (let i = 0; i < symbols.length; i += chunkSize) {
+                entries.push(await this.requestSignedPriceFeedEntry(symbols.slice(i, i + chunkSize)));
+            }
+            try {
+                await this.waitForSignedPriceFeedEntries(entries);
+                await this.validateSignedPriceFeedEntries(entries);
+            }
+            catch (error) {
+                const message = String(error?.message || error);
+                if (!message.includes("too far ahead") &&
+                    !message.includes("expired") &&
+                    !message.includes("price_feed")) {
+                    throw error;
+                }
+                lastClockError = error;
+                await this.sleep(2_000 * (attempt + 1));
+                continue;
+            }
+            return Array.from(new Map(entries.map((feed) => [Buffer.from(feed.payload).toString("hex"), feed])).values());
         }
-        const entry = { payload: b64(d.payload), signature: b64(d.signature), publicKey: b64(d.publicKey) };
-        // API returns a single bundle covering all requested symbols' prices in priceList,
-        // but only one (payload, signature, publicKey) tuple. Map every requested symbol to it.
-        for (const sym of symbols)
-            out.set(sym, entry);
-        return out;
+        throw lastClockError || new Error("Failed to fetch usable signed price feed chunks");
+    }
+    async validateSignedPriceFeedEntries(entries) {
+        if (!entries.length)
+            return;
+        const tx = new transactions.Transaction();
+        this.appendPriceFeedUpdates(tx, entries);
+        tx.setSender(this.walletAddress);
+        const result = await this.suiClient.devInspectTransactionBlock({
+            sender: this.walletAddress,
+            transactionBlock: tx,
+        });
+        const status = result.effects?.status?.status;
+        if (status === "success")
+            return;
+        const error = result.effects?.status?.error || result.error || "unknown price_feed error";
+        throw new Error(`price_feed validation failed: ${error}`);
     }
     /**
      * Build a `price_feed::update_price_feed` PTB command for each provided signed feed
@@ -19079,11 +19483,16 @@ class DipCoinPerpSDK {
         // a single update_price_feed step. Then iterate the on-chain perpetual_registry (which is
         // what new_vault_nav populates, and is_nav_filled requires every entry to be computed).
         const priceFeedId = this.getPriceFeedId();
-        const allSymbols = this.getMarketSymbols();
-        const feeds = await this.fetchSignedPriceFeeds(allSymbols);
-        // Dedup the bundle entries (the API returns one tuple covering all requested symbols).
-        const uniqFeeds = Array.from(new Map(Array.from(feeds.values()).map((f) => [Buffer.from(f.payload).toString("hex"), f])).values());
-        this.appendPriceFeedUpdates(t, uniqFeeds);
+        const configSymbols = this.getMarketSymbols();
+        const configSymbolSet = new Set(configSymbols);
+        const apiSymbols = (await this.getCachedTradingPairs())
+            .map((pair) => pair.symbol)
+            .filter((symbol) => Boolean(symbol) && !configSymbolSet.has(symbol));
+        const updateFeeds = [
+            ...(await this.fetchSignedPriceFeedChunks(configSymbols, 40)),
+            ...(await this.fetchSignedPriceFeedChunks(apiSymbols, 40)),
+        ];
+        this.appendPriceFeedUpdates(t, updateFeeds);
         const perpetualIds = await this.getOnChainPerpetualIds();
         const [nav] = t.moveCall({
             target: `${vaultPkg}::vault::new_vault_nav`,
@@ -19105,11 +19514,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,
         });
     }
     /**
@@ -19118,8 +19525,22 @@ class DipCoinPerpSDK {
     async createVault(args) {
         const tx = new transactions.Transaction();
         const vaultPkg = this.getVaultPackageId();
+        const creator = this.walletAddress;
+        const maxCap = formatNormalToWei(args.maxCap);
+        const minDepositAmount = formatNormalToWei(args.minDepositAmount);
+        const initialAmount = formatNormalToWei(args.initialAmount);
+        const signed = await this.signVaultCreatePayload({
+            creator,
+            name: args.name,
+            trader: args.trader,
+            maxCap,
+            minDepositAmount,
+            creatorMinimumShareRatio: args.creatorMinimumShareRatio,
+            creatorProfitShareRatio: args.creatorProfitShareRatio,
+            initialAmount,
+        });
         tx.moveCall({
-            target: `${vaultPkg}::vault::create_vault`,
+            target: `${vaultPkg}::vault::create_vault_v2`,
             arguments: [
                 tx.object(this.getDeploymentProtocolConfigId()),
                 tx.object("0x6"),
@@ -19127,13 +19548,18 @@ class DipCoinPerpSDK {
                 tx.object(this.getSubAccountsId()),
                 tx.object(this.getBankId()),
                 tx.object(this.getTxIndexerId()),
+                tx.pure.vector("u8", signed.userAddress),
                 tx.pure.string(args.name),
-                tx.pure.address(args.trader),
-                tx.pure.u128(formatNormalToWei(args.maxCap)),
-                tx.pure.u128(formatNormalToWei(args.minDepositAmount)),
+                tx.pure.vector("u8", this.toUnifiedSuiAddressBytes(args.trader)),
+                tx.pure.u128(maxCap),
+                tx.pure.u128(minDepositAmount),
                 tx.pure.u128(args.creatorMinimumShareRatio),
                 tx.pure.u128(args.creatorProfitShareRatio),
-                tx.pure.u128(formatNormalToWei(args.initialAmount)),
+                tx.pure.u128(initialAmount),
+                tx.pure.u128(signed.salt),
+                tx.pure.u64(signed.expiration),
+                tx.pure.vector("u8", signed.signature),
+                tx.pure.vector("u8", signed.publicKey),
             ],
             typeArguments: [this.getCurrencyType()],
         });
@@ -19145,17 +19571,25 @@ class DipCoinPerpSDK {
     async depositToVault(args) {
         const { nav, tx } = await this.buildVaultNavTransaction(args.vaultID, args.markets);
         const vaultPkg = this.getVaultPackageId();
+        const amount = formatNormalToWei(args.amount);
+        const signed = await this.signVaultUserAmountPayload("VaultDeposit", args.vaultID, this.walletAddress, amount);
         tx.moveCall({
-            target: `${vaultPkg}::vault::deposit`,
+            target: `${vaultPkg}::vault::deposit_v2`,
             arguments: [
                 tx.object(this.getDeploymentProtocolConfigId()),
                 tx.object(this.getVaultConfigId()),
                 tx.object("0x6"),
                 tx.object(this.getBankId()),
+                tx.object(this.getSubAccountsId()),
                 tx.object(this.getTxIndexerId()),
                 tx.object(args.vaultID),
                 nav,
-                tx.pure.u128(formatNormalToWei(args.amount)),
+                tx.pure.vector("u8", signed.userAddress),
+                tx.pure.u128(amount),
+                tx.pure.u128(signed.salt),
+                tx.pure.u64(signed.expiration),
+                tx.pure.vector("u8", signed.signature),
+                tx.pure.vector("u8", signed.publicKey),
             ],
             typeArguments: [this.getCurrencyType()],
         });
@@ -19166,32 +19600,25 @@ class DipCoinPerpSDK {
      */
     async requestWithdrawFromVault(args) {
         const tx = new transactions.Transaction();
-        // On mainnet, update Pyth oracle prices before withdraw (contract checks freshness)
-        if (this.options.network === "mainnet") {
-            this.ensurePythClients();
-            if (this.priceServiceConnection && this.pythClient) {
-                const symbols = this.getMarketSymbols();
-                const priceIds = [];
-                for (const sym of symbols) {
-                    const feedId = await this.resolvePriceFeedId(sym);
-                    if (feedId)
-                        priceIds.push(feedId);
-                }
-                if (priceIds.length > 0) {
-                    const priceUpdateData = await this.priceServiceConnection.getPriceFeedsUpdateData(priceIds);
-                    await this.pythClient.updatePriceFeeds(tx, priceUpdateData, priceIds);
-                }
-            }
-        }
         const vaultPkg = this.getVaultPackageId();
+        const shares = formatNormalToWei(args.shares);
+        const signed = await this.signVaultUserAmountPayload("VaultRequestWithdraw", args.vaultID, this.walletAddress, shares);
         tx.moveCall({
-            target: `${vaultPkg}::vault::request_withdraw`,
+            target: `${vaultPkg}::vault::request_withdraw_v2`,
             arguments: [
                 tx.object(this.getDeploymentProtocolConfigId()),
                 tx.object(this.getVaultConfigId()),
                 tx.object("0x6"),
+                tx.object(this.getBankId()),
+                tx.object(this.getSubAccountsId()),
+                tx.object(this.getTxIndexerId()),
                 tx.object(args.vaultID),
-                tx.pure.u128(formatNormalToWei(args.shares)),
+                tx.pure.vector("u8", signed.userAddress),
+                tx.pure.u128(shares),
+                tx.pure.u128(signed.salt),
+                tx.pure.u64(signed.expiration),
+                tx.pure.vector("u8", signed.signature),
+                tx.pure.vector("u8", signed.publicKey),
             ],
             typeArguments: [this.getCurrencyType()],
         });
@@ -19207,7 +19634,7 @@ class DipCoinPerpSDK {
             elements: args.withdrawalRequestIDs.map((id) => tx.object(id)),
         });
         tx.moveCall({
-            target: `${vaultPkg}::vault::fill_withdrawal_requests`,
+            target: `${vaultPkg}::vault::fill_withdrawal_requests_v2`,
             arguments: [
                 tx.object(this.getDeploymentProtocolConfigId()),
                 tx.object(this.getVaultConfigId()),
@@ -19228,16 +19655,23 @@ class DipCoinPerpSDK {
     async closeVault(args) {
         const { nav, tx } = await this.buildVaultNavTransaction(args.vaultID, args.markets);
         const vaultPkg = this.getVaultPackageId();
+        const signed = await this.signVaultUserPayload("VaultClose", args.vaultID, this.walletAddress);
         tx.moveCall({
-            target: `${vaultPkg}::vault::close_vault_v2`,
+            target: `${vaultPkg}::vault::close_vault_v3`,
             arguments: [
                 tx.object(this.getDeploymentProtocolConfigId()),
                 tx.object(this.getVaultConfigId()),
                 tx.object(this.getSubAccountsId()),
+                tx.object(this.getTxIndexerId()),
                 tx.object(args.vaultID),
                 tx.object(this.getBankId()),
                 tx.object("0x6"),
                 nav,
+                tx.pure.vector("u8", signed.userAddress),
+                tx.pure.u128(signed.salt),
+                tx.pure.u64(signed.expiration),
+                tx.pure.vector("u8", signed.signature),
+                tx.pure.vector("u8", signed.publicKey),
             ],
             typeArguments: [this.getCurrencyType()],
         });
@@ -19267,14 +19701,22 @@ class DipCoinPerpSDK {
     async claimClosedVaultFunds(args) {
         const tx = new transactions.Transaction();
         const vaultPkg = this.getVaultPackageId();
+        const signed = await this.signVaultUserPayload("VaultClaimClosedFunds", args.vaultID, this.walletAddress);
         tx.moveCall({
-            target: `${vaultPkg}::vault::claim_closed_vault_funds`,
+            target: `${vaultPkg}::vault::claim_closed_vault_funds_v2`,
             arguments: [
                 tx.object(this.getDeploymentProtocolConfigId()),
                 tx.object(this.getVaultConfigId()),
                 tx.object(this.getBankId()),
+                tx.object(this.getSubAccountsId()),
                 tx.object(this.getTxIndexerId()),
                 tx.object(args.vaultID),
+                tx.object("0x6"),
+                tx.pure.vector("u8", signed.userAddress),
+                tx.pure.u128(signed.salt),
+                tx.pure.u64(signed.expiration),
+                tx.pure.vector("u8", signed.signature),
+                tx.pure.vector("u8", signed.publicKey),
             ],
             typeArguments: [this.getCurrencyType()],
         });
@@ -19286,14 +19728,23 @@ class DipCoinPerpSDK {
     async setVaultTrader(args) {
         const tx = new transactions.Transaction();
         const vaultPkg = this.getVaultPackageId();
+        const signed = await this.signVaultSetTraderPayload(args.vaultID, this.walletAddress, args.newTrader);
         tx.moveCall({
-            target: `${vaultPkg}::vault::set_trader`,
+            target: `${vaultPkg}::vault::set_trader_v2`,
             arguments: [
                 tx.object(this.getDeploymentProtocolConfigId()),
                 tx.object(this.getVaultConfigId()),
                 tx.object(args.vaultID),
                 tx.object(this.getSubAccountsId()),
-                tx.pure.address(args.newTrader),
+                tx.object(this.getTxIndexerId()),
+                tx.object(this.getBankId()),
+                tx.object("0x6"),
+                tx.pure.vector("u8", signed.userAddress),
+                tx.pure.vector("u8", this.toUnifiedSuiAddressBytes(args.newTrader)),
+                tx.pure.u128(signed.salt),
+                tx.pure.u64(signed.expiration),
+                tx.pure.vector("u8", signed.signature),
+                tx.pure.vector("u8", signed.publicKey),
             ],
             typeArguments: [this.getCurrencyType()],
         });
@@ -19305,15 +19756,24 @@ class DipCoinPerpSDK {
     async setVaultSubTrader(args) {
         const tx = new transactions.Transaction();
         const vaultPkg = this.getVaultPackageId();
+        const signed = await this.signVaultSetSubTraderPayload(args.vaultID, this.walletAddress, args.subTrader, args.status);
         tx.moveCall({
-            target: `${vaultPkg}::vault::set_sub_trader`,
+            target: `${vaultPkg}::vault::set_sub_trader_v2`,
             arguments: [
                 tx.object(this.getDeploymentProtocolConfigId()),
                 tx.object(this.getVaultConfigId()),
                 tx.object(args.vaultID),
                 tx.object(this.getSubAccountsId()),
-                tx.pure.address(args.subTrader),
+                tx.object(this.getTxIndexerId()),
+                tx.object(this.getBankId()),
+                tx.object("0x6"),
+                tx.pure.vector("u8", signed.userAddress),
+                tx.pure.vector("u8", this.toUnifiedSuiAddressBytes(args.subTrader)),
                 tx.pure.bool(args.status),
+                tx.pure.u128(signed.salt),
+                tx.pure.u64(signed.expiration),
+                tx.pure.vector("u8", signed.signature),
+                tx.pure.vector("u8", signed.publicKey),
             ],
             typeArguments: [this.getCurrencyType()],
         });
@@ -19325,13 +19785,23 @@ class DipCoinPerpSDK {
     async setVaultDepositStatus(args) {
         const tx = new transactions.Transaction();
         const vaultPkg = this.getVaultPackageId();
+        const signed = await this.signVaultDepositStatusPayload(args.vaultID, this.walletAddress, args.status);
         tx.moveCall({
-            target: `${vaultPkg}::vault::set_deposit_status`,
+            target: `${vaultPkg}::vault::set_deposit_status_v2`,
             arguments: [
                 tx.object(this.getDeploymentProtocolConfigId()),
                 tx.object(this.getVaultConfigId()),
                 tx.object(args.vaultID),
+                tx.object(this.getSubAccountsId()),
+                tx.object(this.getTxIndexerId()),
+                tx.object(this.getBankId()),
+                tx.object("0x6"),
+                tx.pure.vector("u8", signed.userAddress),
                 tx.pure.bool(args.status),
+                tx.pure.u128(signed.salt),
+                tx.pure.u64(signed.expiration),
+                tx.pure.vector("u8", signed.signature),
+                tx.pure.vector("u8", signed.publicKey),
             ],
             typeArguments: [this.getCurrencyType()],
         });
@@ -19343,13 +19813,24 @@ class DipCoinPerpSDK {
     async setVaultMaxCap(args) {
         const tx = new transactions.Transaction();
         const vaultPkg = this.getVaultPackageId();
+        const amount = formatNormalToWei(args.maxCap);
+        const signed = await this.signVaultCreatorAmountPayload("VaultSetMaxCap", args.vaultID, this.walletAddress, amount);
         tx.moveCall({
-            target: `${vaultPkg}::vault::set_max_cap`,
+            target: `${vaultPkg}::vault::set_max_cap_v2`,
             arguments: [
                 tx.object(this.getDeploymentProtocolConfigId()),
                 tx.object(this.getVaultConfigId()),
                 tx.object(args.vaultID),
-                tx.pure.u128(formatNormalToWei(args.maxCap)),
+                tx.object(this.getSubAccountsId()),
+                tx.object(this.getTxIndexerId()),
+                tx.object(this.getBankId()),
+                tx.object("0x6"),
+                tx.pure.vector("u8", signed.userAddress),
+                tx.pure.u128(amount),
+                tx.pure.u128(signed.salt),
+                tx.pure.u64(signed.expiration),
+                tx.pure.vector("u8", signed.signature),
+                tx.pure.vector("u8", signed.publicKey),
             ],
             typeArguments: [this.getCurrencyType()],
         });
@@ -19361,13 +19842,24 @@ class DipCoinPerpSDK {
     async setVaultMinDepositAmount(args) {
         const tx = new transactions.Transaction();
         const vaultPkg = this.getVaultPackageId();
+        const amount = formatNormalToWei(args.minDepositAmount);
+        const signed = await this.signVaultCreatorAmountPayload("VaultSetMinDepositAmount", args.vaultID, this.walletAddress, amount);
         tx.moveCall({
-            target: `${vaultPkg}::vault::set_min_deposit_amount`,
+            target: `${vaultPkg}::vault::set_min_deposit_amount_v2`,
             arguments: [
                 tx.object(this.getDeploymentProtocolConfigId()),
                 tx.object(this.getVaultConfigId()),
                 tx.object(args.vaultID),
-                tx.pure.u128(formatNormalToWei(args.minDepositAmount)),
+                tx.object(this.getSubAccountsId()),
+                tx.object(this.getTxIndexerId()),
+                tx.object(this.getBankId()),
+                tx.object("0x6"),
+                tx.pure.vector("u8", signed.userAddress),
+                tx.pure.u128(amount),
+                tx.pure.u128(signed.salt),
+                tx.pure.u64(signed.expiration),
+                tx.pure.vector("u8", signed.signature),
+                tx.pure.vector("u8", signed.publicKey),
             ],
             typeArguments: [this.getCurrencyType()],
         });
@@ -19379,13 +19871,23 @@ class DipCoinPerpSDK {
     async setVaultAutoCloseOnWithdraw(args) {
         const tx = new transactions.Transaction();
         const vaultPkg = this.getVaultPackageId();
+        const signed = await this.signVaultAutoClosePayload(args.vaultID, this.walletAddress, args.autoCloseOnWithdraw);
         tx.moveCall({
-            target: `${vaultPkg}::vault::set_auto_close_on_withdraw`,
+            target: `${vaultPkg}::vault::set_auto_close_on_withdraw_v2`,
             arguments: [
                 tx.object(this.getDeploymentProtocolConfigId()),
                 tx.object(this.getVaultConfigId()),
                 tx.object(args.vaultID),
+                tx.object(this.getSubAccountsId()),
+                tx.object(this.getTxIndexerId()),
+                tx.object(this.getBankId()),
+                tx.object("0x6"),
+                tx.pure.vector("u8", signed.userAddress),
                 tx.pure.bool(args.autoCloseOnWithdraw),
+                tx.pure.u128(signed.salt),
+                tx.pure.u64(signed.expiration),
+                tx.pure.vector("u8", signed.signature),
+                tx.pure.vector("u8", signed.publicKey),
             ],
             typeArguments: [this.getCurrencyType()],
         });
@@ -19660,12 +20162,12 @@ function initDipCoinPerpSDK(privateKey, options) {
 
 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 });
+}
 if (fs__default["default"].existsSync(localEnv)) {
     dotenv__default["default"].config({ path: localEnv });
 }
-else if (fs__default["default"].existsSync(globalEnv)) {
-    dotenv__default["default"].config({ path: globalEnv });
-}
 // Cache SDK instance
 let cachedSDK = null;
 /**
@@ -19712,9 +20214,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).
@@ -19724,7 +20230,8 @@ function getSDK() {
         return cachedSDK;
     const keypair = getKeypair();
     const network = getNetwork();
-    cachedSDK = initDipCoinPerpSDK(keypair, { network });
+    const customRpc = process.env.DIPCOIN_RPC_URL || process.env.SUI_RPC_URL;
+    cachedSDK = initDipCoinPerpSDK(keypair, { network, customRpc });
     tryAutoBindReferral(cachedSDK);
     return cachedSDK;
 }
@@ -20396,7 +20903,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) ---");
@@ -20703,7 +21213,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") {
@@ -20731,7 +21243,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")
@@ -20773,7 +21294,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)],
@@ -21045,7 +21569,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) {
@@ -21062,7 +21589,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) {