dipcoin-cli 1.3.3 → 1.3.4

package/dist/cli.cjs

@@ -16653,21 +16653,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 +16701,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) {
@@ -18688,6 +18736,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 +18869,16 @@ 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 +18888,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) {
@@ -18997,6 +19179,105 @@ 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();
+        while (true) {
+            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() - start + waitMs > 180_000) {
+                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();
+        while (true) {
+            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() - start + waitMs > 180_000) {
+                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 +19291,75 @@ 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 +19413,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`,
@@ -19118,8 +19457,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 +19480,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 +19503,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 +19532,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 +19566,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 +19587,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 +19633,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 +19660,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 +19688,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 +19717,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 +19745,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 +19774,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 +19803,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 +20094,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;
 /**
@@ -19724,7 +20158,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;
 }