aftermath-ts-sdk 1.3.26-perps.13 → 1.3.27

package/dist/packages/perpetuals/perpetualsAccount.js

@@ -22,82 +22,230 @@ var __rest = (this && this.__rest) || function (s, e) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PerpetualsAccount = void 0;
 const caller_1 = require("../../general/utils/caller");
+const types_1 = require("../../types");
+const iFixedUtils_1 = require("../../general/utils/iFixedUtils");
 const utils_1 = require("../../general/utils");
 const perpetuals_1 = require("./perpetuals");
-const transactions_1 = require("@mysten/sui/transactions");
-/**
- * Note on “refreshing” account state:
- *
- * This class is a thin wrapper around a snapshot of {@link PerpetualsAccountObject}
- * that is typically fetched via {@link Perpetuals.getAccount}. The transaction builders
- * use the current snapshot to derive fields like `hasPosition` and to construct
- * SL/TP helpers that depend on the position side.
- *
- * If your app is long-lived, you may want to periodically re-fetch the account
- * (and recreate this wrapper) to avoid stale local position/order state. For example:
- * - After placing/canceling orders
- * - After fills/liquidations/funding settlements
- * - After switching markets or wallets
- */
-/**
- * High-level wrapper around a single Perpetuals account or vault account.
- *
- * This class encapsulates:
- *
- * - Transaction builders for:
- *   - Collateral actions (deposit, withdraw, allocate, deallocate, transfer)
- *   - Orders (market/limit, cancel, stop orders, SL/TP, set leverage)
- * - Read-only account helpers:
- *   - Stop-order message signing
- *   - Order & stop-order metadata
- *   - Collateral & trade history
- * - Convenience helpers to:
- *   - Fetch and categorize SL/TP stop orders
- *   - Resolve account/vault identifiers and owner addresses
- *
- * You typically do not construct `PerpetualsAccount` directly. Instead, use
- * {@link Perpetuals.getAccount} or {@link Perpetuals.getAccounts}, which
- * fetch all required on-chain data and wrap it for you:
- *
- * ```ts
- * const afSdk = new Aftermath("MAINNET");
- * await afSdk.init();
- *
- * const perps = afSdk.Perpetuals();
- * const [accountCap] = await perps.getOwnedAccountCaps({
- *   walletAddress: "0x...",
- * });
- *
- * const account = await perps.getAccount({ accountCap });
- *
- * // Build a deposit transaction
- * const depositTx = await account.getDepositCollateralTx({
- *   depositAmount: BigInt("1000000000"),
- * });
- * ```
- */
+const __1 = require("..");
 class PerpetualsAccount extends caller_1.Caller {
     // =========================================================================
     //  Constructor
     // =========================================================================
-    /**
-     * Create a new {@link PerpetualsAccount} wrapper.
-     *
-     * @param account - Raw account object with positions and equity data.
-     * @param accountCap - Account cap or partial vault cap object containing
-     *   ownership and collateral metadata.
-     * @param config - Optional {@link CallerConfig} (network, auth, etc.).
-     * @param Provider - Optional shared {@link AftermathApi} provider instance
-     *   used to derive serialized transaction kinds (`txKind`) from
-     *   {@link Transaction} objects.
-     */
-    constructor(account, accountCap, config, Provider) {
-        const vaultId = "vaultId" in accountCap ? accountCap.vaultId : undefined;
+    constructor(account, accountCap, config) {
         super(config, "perpetuals");
         this.account = account;
         this.accountCap = accountCap;
-        this.Provider = Provider;
-        this.vaultId = vaultId;
+        // =========================================================================
+        //  Calculations
+        // =========================================================================
+        this.calcFreeCollateralForPosition = (inputs) => {
+            var _a, _b;
+            const marketId = inputs.market.marketId;
+            const position = (_b = (_a = inputs.position) !== null && _a !== void 0 ? _a : this.positionForMarketId({ marketId })) !== null && _b !== void 0 ? _b : this.emptyPosition({ market: inputs.market });
+            const funding = this.calcUnrealizedFundingsForPosition(inputs);
+            const { pnl, minInitialMargin } = this.calcPnLAndMarginForPosition(inputs);
+            let collateralUsd = iFixedUtils_1.IFixedUtils.numberFromIFixed(position.collateral) *
+                inputs.collateralPrice;
+            collateralUsd += funding;
+            let cappedMargin;
+            if (pnl < 0) {
+                cappedMargin = collateralUsd + pnl;
+            }
+            else {
+                cappedMargin = collateralUsd;
+            }
+            if (cappedMargin >= minInitialMargin) {
+                return (cappedMargin - minInitialMargin) / inputs.collateralPrice;
+            }
+            else
+                return 0;
+        };
+        this.calcMarginRatioAndLeverageForPosition = (inputs) => {
+            var _a, _b;
+            const { market, indexPrice, collateralPrice } = inputs;
+            const marketId = market.marketId;
+            const position = (_b = (_a = inputs.position) !== null && _a !== void 0 ? _a : this.positionForMarketId({ marketId })) !== null && _b !== void 0 ? _b : this.emptyPosition({ market });
+            const funding = this.calcUnrealizedFundingsForPosition({
+                market,
+                position,
+            });
+            const collateralUsd = iFixedUtils_1.IFixedUtils.numberFromIFixed(position === null || position === void 0 ? void 0 : position.collateral) *
+                collateralPrice +
+                funding;
+            const { pnl, netAbsBaseValue } = this.calcPnLAndMarginForPosition({
+                market,
+                indexPrice,
+                position,
+            });
+            const marginRatio = netAbsBaseValue === 0 ? 0 : (collateralUsd + pnl) / netAbsBaseValue;
+            const leverage = marginRatio === 0 ? 0 : 1 / marginRatio;
+            return {
+                marginRatio,
+                leverage,
+            };
+        };
+        this.calcUnrealizedFundings = (inputs) => {
+            let totalFunding = 0;
+            inputs.markets.forEach((market) => {
+                totalFunding += this.calcUnrealizedFundingsForPosition({
+                    market,
+                });
+            });
+            return totalFunding;
+        };
+        this.calcUnrealizedFundingsForPosition = (inputs) => {
+            var _a, _b;
+            const marketId = inputs.market.marketId;
+            const position = (_b = (_a = inputs.position) !== null && _a !== void 0 ? _a : this.positionForMarketId({ marketId })) !== null && _b !== void 0 ? _b : this.emptyPosition({ market: inputs.market });
+            const baseAmount = iFixedUtils_1.IFixedUtils.numberFromIFixed(position.baseAssetAmount);
+            const isLong = Math.sign(baseAmount);
+            if (isLong < 0) {
+                const fundingShort = iFixedUtils_1.IFixedUtils.numberFromIFixed(position.cumFundingRateShort);
+                const marketFundingShort = iFixedUtils_1.IFixedUtils.numberFromIFixed(inputs.market.marketState.cumFundingRateShort);
+                return -baseAmount * (marketFundingShort - fundingShort);
+            }
+            else {
+                const fundingLong = iFixedUtils_1.IFixedUtils.numberFromIFixed(position.cumFundingRateLong);
+                const marketFundingLong = iFixedUtils_1.IFixedUtils.numberFromIFixed(inputs.market.marketState.cumFundingRateLong);
+                return -baseAmount * (marketFundingLong - fundingLong);
+            }
+        };
+        this.calcPnLAndMarginForPosition = (inputs) => {
+            var _a, _b;
+            const marketId = inputs.market.marketId;
+            const position = (_b = (_a = inputs.position) !== null && _a !== void 0 ? _a : this.positionForMarketId({ marketId })) !== null && _b !== void 0 ? _b : this.emptyPosition({ market: inputs.market });
+            const marginRatioInitial = 1 / position.leverage;
+            // const marginRatioInitial = inputs.market.initialMarginRatio();
+            const marginRatioMaintenance = iFixedUtils_1.IFixedUtils.numberFromIFixed(inputs.market.marketParams.marginRatioMaintenance);
+            const baseAssetAmount = iFixedUtils_1.IFixedUtils.numberFromIFixed(position.baseAssetAmount);
+            const quoteAssetAmount = iFixedUtils_1.IFixedUtils.numberFromIFixed(position.quoteAssetNotionalAmount);
+            const bidsQuantity = iFixedUtils_1.IFixedUtils.numberFromIFixed(position.bidsQuantity);
+            const asksQuantity = iFixedUtils_1.IFixedUtils.numberFromIFixed(position.asksQuantity);
+            const pnl = baseAssetAmount * inputs.indexPrice - quoteAssetAmount;
+            const netAbs = Math.max(Math.abs(baseAssetAmount + bidsQuantity), Math.abs(baseAssetAmount - asksQuantity));
+            const netAbsBaseValue = netAbs * inputs.indexPrice;
+            const minInitialMargin = netAbsBaseValue * marginRatioInitial;
+            const minMaintenanceMargin = netAbsBaseValue * marginRatioMaintenance;
+            return { pnl, minInitialMargin, minMaintenanceMargin, netAbsBaseValue };
+        };
+        this.calcLiquidationPriceForPosition = (inputs) => {
+            var _a, _b;
+            const marketId = inputs.market.marketId;
+            const position = (_b = (_a = inputs.position) !== null && _a !== void 0 ? _a : this.positionForMarketId({ marketId })) !== null && _b !== void 0 ? _b : this.emptyPosition({ market: inputs.market });
+            const funding = this.calcUnrealizedFundingsForPosition(inputs);
+            const collateralUsd = iFixedUtils_1.IFixedUtils.numberFromIFixed(position === null || position === void 0 ? void 0 : position.collateral) *
+                inputs.collateralPrice +
+                funding;
+            const baseAssetAmount = iFixedUtils_1.IFixedUtils.numberFromIFixed(position.baseAssetAmount);
+            const quoteAssetAmount = iFixedUtils_1.IFixedUtils.numberFromIFixed(position.quoteAssetNotionalAmount);
+            const MMR = iFixedUtils_1.IFixedUtils.numberFromIFixed(inputs.market.marketParams.marginRatioMaintenance);
+            const numerator = collateralUsd - quoteAssetAmount;
+            const price = (() => {
+                if (baseAssetAmount > 0) {
+                    return numerator / ((1 - MMR) * -baseAssetAmount);
+                }
+                else {
+                    return numerator / ((1 + MMR) * -baseAssetAmount);
+                }
+            })();
+            return price < 0 ? 0 : price;
+        };
+        this.calcFreeMarginUsdForPosition = (inputs) => {
+            var _a, _b;
+            const marketId = inputs.market.marketId;
+            const position = (_b = (_a = inputs.position) !== null && _a !== void 0 ? _a : this.positionForMarketId({ marketId })) !== null && _b !== void 0 ? _b : this.emptyPosition({ market: inputs.market });
+            const totalFunding = this.calcUnrealizedFundingsForPosition(inputs);
+            const { pnl, minInitialMargin } = this.calcPnLAndMarginForPosition(inputs);
+            let collateralUsd = iFixedUtils_1.IFixedUtils.numberFromIFixed(position.collateral) *
+                inputs.collateralPrice;
+            const margin = collateralUsd + totalFunding + pnl;
+            if (margin >= minInitialMargin) {
+                return margin - minInitialMargin;
+            }
+            else
+                return 0;
+        };
+        this.calcAccountState = (inputs) => {
+            const zipped = utils_1.Helpers.zip(inputs.markets, inputs.indexPrices);
+            let accountEquity = 0;
+            let totalPnL = 0;
+            let totalFunding = 0;
+            let totalCollateralAllocated = 0;
+            zipped.forEach(([market, indexPrice]) => {
+                var _a;
+                const marketId = market.marketId;
+                const position = (_a = this.positionForMarketId({ marketId })) !== null && _a !== void 0 ? _a : this.emptyPosition({ market });
+                const funding = this.calcUnrealizedFundingsForPosition({
+                    market,
+                    position,
+                });
+                const { pnl } = this.calcPnLAndMarginForPosition({
+                    market,
+                    indexPrice,
+                    position,
+                });
+                let collateralUsd = iFixedUtils_1.IFixedUtils.numberFromIFixed(position.collateral) *
+                    inputs.collateralPrice;
+                totalPnL += pnl;
+                totalFunding += funding;
+                totalCollateralAllocated += collateralUsd;
+                accountEquity += collateralUsd + funding + pnl;
+            });
+            return {
+                accountEquity,
+                totalPnL,
+                totalFunding,
+                totalCollateralAllocated,
+            };
+        };
+        this.closePositionTxInputs = (inputs) => {
+            var _a;
+            const { size, market, walletAddress, orderDatas, collateralPrice } = inputs;
+            const marketId = market.marketId;
+            const position = (_a = this.positionForMarketId({ marketId })) !== null && _a !== void 0 ? _a : this.emptyPosition({ market });
+            // TODO: move conversion to helper function, since used often
+            const ordersCollateral = __1.Coin.normalizeBalance(utils_1.Helpers.sum(orderDatas
+                .filter((orderData) => orderData.marketId === market.marketId)
+                .map((orderData) => market.calcCollateralUsedForOrder(Object.assign(Object.assign({}, inputs), { orderData, leverage: position.leverage })).collateral)), this.collateralDecimals());
+            const fullPositionCollateralChange = utils_1.Helpers.maxBigInt(BigInt(Math.floor(Number(__1.Coin.normalizeBalance(this.calcFreeMarginUsdForPosition(inputs) *
+                collateralPrice, this.collateralDecimals()) - ordersCollateral) *
+                (1 -
+                    PerpetualsAccount.constants
+                        .closePositionMarginOfError))), BigInt(0)) * BigInt(-1);
+            const positionSize = BigInt(Math.round(Math.abs(utils_1.Casting.IFixed.numberFromIFixed(position.baseAssetAmount) /
+                market.lotSize())));
+            const collateralChange = BigInt(Math.round(Number(fullPositionCollateralChange) *
+                (Number(size) / Number(positionSize))));
+            const positionSide = perpetuals_1.Perpetuals.positionSide(position);
+            return {
+                size,
+                marketId,
+                walletAddress,
+                collateralChange,
+                side: positionSide === types_1.PerpetualsOrderSide.Bid
+                    ? types_1.PerpetualsOrderSide.Ask
+                    : types_1.PerpetualsOrderSide.Bid,
+                hasPosition: this.positionForMarketId({ marketId }) !== undefined,
+            };
+        };
+        this.emptyPosition = (inputs) => {
+            const { market } = inputs;
+            return {
+                marketId: market.marketId,
+                collateralCoinType: this.accountCap.collateralCoinType,
+                collateral: BigInt(0),
+                baseAssetAmount: BigInt(0),
+                quoteAssetNotionalAmount: BigInt(0),
+                cumFundingRateLong: market.marketState.cumFundingRateLong,
+                cumFundingRateShort: market.marketState.cumFundingRateShort,
+                asksQuantity: BigInt(0),
+                bidsQuantity: BigInt(0),
+                pendingOrders: [],
+                makerFee: BigInt(1000000000000000000), // 100%
+                takerFee: BigInt(1000000000000000000), // 100%
+                leverage: 1,
+            };
+        };
     }
     // =========================================================================
     //  Transactions
@@ -105,1026 +253,174 @@ class PerpetualsAccount extends caller_1.Caller {
     // =========================================================================
     //  Collateral Txs
     // =========================================================================
-    /**
-     * Build a `deposit-collateral` transaction for this account.
-     *
-     * For non-vault accounts, this endpoint constructs a transaction that:
-     * - Optionally extends an existing {@link Transaction}, and
-     * - Deposits collateral into the Perpetuals account.
-     *
-     * **Note:** Vault accounts are currently not supported and will throw.
-     *
-     * @param inputs.tx - Optional existing transaction to extend. If omitted,
-     *   a new {@link Transaction} is created under the hood.
-     * @param inputs.isSponsoredTx - Optional flag indicating whether the
-     *   transaction is gas-sponsored.
-     * @param inputs.depositAmount - Amount of collateral to deposit, if paying
-     *   directly from the wallet.
-     * @param inputs.depositCoinArg - Transaction object argument referencing a
-     *   coin to deposit (mutually exclusive with `depositAmount`).
-     *
-     * @returns Transaction response containing a `tx`.
-     *
-     * @example
-     * ```ts
-     * const { tx } = await account.getDepositCollateralTx({
-     *   depositAmount: BigInt("1000000000"),
-     * });
-     * ```
-     */
     getDepositCollateralTx(inputs) {
         return __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            const { tx } = inputs, otherInputs = __rest(inputs, ["tx"]);
-            if ("vaultId" in this.accountCap)
-                throw new Error("`getDepositCollateralTx` not supported by vault accounts, please use method `getAdminDepositTx` on class `PerpetualsVault` instead");
-            return this.fetchApiTxObject("account/transactions/deposit-collateral", Object.assign(Object.assign({}, otherInputs), { walletAddress: this.ownerAddress(), collateralCoinType: this.accountCap.collateralCoinType, accountId: this.accountCap.accountId, accountCapId: this.accountCap.objectId, txKind: yield ((_a = this.Provider) === null || _a === void 0 ? void 0 : _a.Transactions().fetchBase64TxKindFromTx({
-                    tx: tx !== null && tx !== void 0 ? tx : new transactions_1.Transaction(),
-                })) }), undefined, {
-                txKind: true,
-            });
+            return this.fetchApiTransaction("transactions/deposit-collateral", Object.assign(Object.assign({}, inputs), { collateralCoinType: this.accountCap.collateralCoinType, accountCapId: this.accountCap.objectId }));
         });
     }
-    /**
-     * Build a `withdraw-collateral` transaction for this account.
-     *
-     * For non-vault accounts, this endpoint constructs a transaction to:
-     * - Withdraw collateral from the Perpetuals account, and
-     * - Optionally transfer it to a `recipientAddress` (otherwise coin is left
-     *   as a transaction argument).
-     *
-     * **Note:** Vault accounts are currently not supported and will throw.
-     *
-     * @param inputs.withdrawAmount - Amount of collateral to withdraw.
-     * @param inputs.recipientAddress - Optional address to receive the withdrawn
-     *   coins directly.
-     * @param inputs.tx - Optional transaction to extend (defaults to new `Transaction()`).
-     *
-     * @returns A response containing `tx` and the `coinOutArg` where the
-     *   withdrawn coins end up if `recipientAddress` is not used.
-     *
-     * @example
-     * ```ts
-     * const { tx, coinOutArg } = await account.getWithdrawCollateralTx({
-     *   withdrawAmount: BigInt("1000000000"),
-     * });
-     * ```
-     */
     getWithdrawCollateralTx(inputs) {
         return __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            const { withdrawAmount, recipientAddress, tx: txFromInputs } = inputs;
-            if (this.vaultId)
-                throw new Error("this method is not supported for vaults, please use method `getAdminWithdrawTx` on class `PerpetualsVault` instead");
-            return this.fetchApiTxObject("account/transactions/withdraw-collateral", {
-                withdrawAmount,
-                recipientAddress,
-                walletAddress: this.ownerAddress(),
-                accountId: this.accountCap.accountId,
-                txKind: yield ((_a = this.Provider) === null || _a === void 0 ? void 0 : _a.Transactions().fetchBase64TxKindFromTx({
-                    tx: txFromInputs !== null && txFromInputs !== void 0 ? txFromInputs : new transactions_1.Transaction(),
-                })),
-            }, undefined, {
-                txKind: true,
-            });
+            return this.fetchApiTransaction("transactions/withdraw-collateral", Object.assign(Object.assign({}, inputs), { collateralCoinType: this.accountCap.collateralCoinType, accountCapId: this.accountCap.objectId }));
         });
     }
-    /**
-     * Build an `allocate-collateral` transaction, moving collateral from this
-     * account into a specific market (clearing house).
-     *
-     * Works for both account-backed and vault-backed accounts.
-     *
-     * @param inputs.marketId - Market to allocate collateral to.
-     * @param inputs.allocateAmount - Amount of collateral to allocate.
-     * @param inputs.tx - Optional transaction to extend.
-     *
-     * @returns Transaction response containing a `tx`.
-     */
     getAllocateCollateralTx(inputs) {
         return __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            const { tx, allocateAmount, marketId } = inputs;
-            return this.fetchApiTxObject(`${this.vaultId ? "vault" : "account"}/` +
-                "transactions/allocate-collateral", Object.assign(Object.assign({ marketId,
-                allocateAmount }, ("vaultId" in this.accountCap
-                ? {
-                    vaultId: this.accountCap.vaultId,
-                    accountId: undefined,
-                }
-                : {
-                    accountId: this.accountCap.accountId,
-                    accountCapId: this.accountCap.objectId,
-                    vaultId: undefined,
-                })), { walletAddress: this.ownerAddress(), txKind: yield ((_a = this.Provider) === null || _a === void 0 ? void 0 : _a.Transactions().fetchBase64TxKindFromTx({ tx: tx !== null && tx !== void 0 ? tx : new transactions_1.Transaction() })) }), undefined, {
-                txKind: true,
-            });
+            const { market } = inputs;
+            return this.fetchApiTransaction("transactions/allocate-collateral", Object.assign(Object.assign({}, inputs), { packageId: market.marketData.packageId, marketInitialSharedVersion: market.marketData.initialSharedVersion, marketId: market.marketId, collateralCoinType: this.accountCap.collateralCoinType, accountCapId: this.accountCap.objectId }));
         });
     }
-    /**
-     * Build a `deallocate-collateral` transaction, moving collateral from a
-     * specific market back to this account.
-     *
-     * Works for both account-backed and vault-backed accounts.
-     *
-     * @param inputs.marketId - Market to deallocate collateral from.
-     * @param inputs.deallocateAmount - Amount of collateral to deallocate.
-     * @param inputs.tx - Optional transaction to extend.
-     *
-     * @returns Transaction response containing a `tx`.
-     */
     getDeallocateCollateralTx(inputs) {
         return __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            const { tx, deallocateAmount, marketId } = inputs;
-            return this.fetchApiTxObject(`${this.vaultId ? "vault" : "account"}/` +
-                "transactions/deallocate-collateral", Object.assign(Object.assign({ marketId,
-                deallocateAmount }, ("vaultId" in this.accountCap
-                ? {
-                    vaultId: this.accountCap.vaultId,
-                    accountId: undefined,
-                }
-                : {
-                    accountId: this.accountCap.accountId,
-                    accountCapId: this.accountCap.objectId,
-                    vaultId: undefined,
-                })), { walletAddress: this.ownerAddress(), txKind: yield ((_a = this.Provider) === null || _a === void 0 ? void 0 : _a.Transactions().fetchBase64TxKindFromTx({ tx: tx !== null && tx !== void 0 ? tx : new transactions_1.Transaction() })) }), undefined, {
-                txKind: true,
-            });
+            const { market } = inputs;
+            return this.fetchApiTransaction("transactions/deallocate-collateral", Object.assign(Object.assign({}, inputs), { packageId: market.marketData.packageId, marketInitialSharedVersion: market.marketData.initialSharedVersion, marketId: market.marketId, basePriceFeedId: market.marketParams.basePriceFeedId, collateralPriceFeedId: market.marketParams.collateralPriceFeedId, collateralCoinType: this.accountCap.collateralCoinType, accountCapId: this.accountCap.objectId }));
         });
     }
-    /**
-     * Build a `transfer-collateral` transaction between two Perpetuals accounts.
-     *
-     * Only supported for direct accounts, **not** vault-backed accounts.
-     *
-     * @param inputs.transferAmount - Amount of collateral to transfer.
-     * @param inputs.toAccountId - Destination account ID.
-     * @param inputs.tx - Optional transaction to extend.
-     *
-     * @returns Transaction response containing a `tx`.
-     */
     getTransferCollateralTx(inputs) {
         return __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            const { transferAmount, toAccountId, toAccountCapId, tx } = inputs;
-            if ("vaultId" in this.accountCap)
-                throw new Error("`getTransferCollateralTx` not supported by vault accounts");
-            return this.fetchApiTxObject(`${this.vaultId ? "vault" : "account"}/` +
-                "transactions/transfer-collateral", {
-                transferAmount,
-                toAccountId,
-                toAccountCapId,
-                walletAddress: this.ownerAddress(),
-                fromAccountId: this.accountCap.accountId,
-                fromAccountCapId: this.accountCap.objectId,
-                txKind: yield ((_a = this.Provider) === null || _a === void 0 ? void 0 : _a.Transactions().fetchBase64TxKindFromTx({ tx: tx !== null && tx !== void 0 ? tx : new transactions_1.Transaction() })),
-            }, undefined, {
-                txKind: true,
-            });
+            return this.fetchApiTransaction("transactions/transfer-collateral", Object.assign(Object.assign({}, inputs), { collateralCoinType: this.accountCap.collateralCoinType, fromAccountCapId: this.accountCap.objectId }));
         });
     }
     // =========================================================================
     //  Order Txs
     // =========================================================================
-    /**
-     * Build a `place-market-order` transaction for this account.
-     *
-     * This is the primary entrypoint for opening/closing positions via market orders.
-     * It automatically:
-     * - Injects the account/vault identity into the payload.
-     * - Derives `hasPosition` based on the current account state for the given market.
-     * - Optionally attaches SL/TP stop orders via the `slTp` input.
-     *
-     * Important behavioral notes:
-     * - `hasPosition` is derived from the local {@link PerpetualsAccountObject} snapshot.
-     *   If the snapshot is stale, consider re-fetching the account first.
-     * - For vault-backed accounts, the API routes to `/perpetuals/vault/...` and uses
-     *   `vaultId` as the identity discriminator. For direct accounts, it uses `accountId`.
-     *
-     * @param inputs - See {@link SdkPerpetualsPlaceMarketOrderInputs} for details.
-     *   Notably:
-     *   - `marketId`, `side`, `size`, `collateralChange`, `reduceOnly`
-     *   - Optional `leverage`
-     *   - Optional `slTp` params
-     *   - Optional `tx` to extend
-     *
-     * @returns Transaction response containing `tx`.
-     *
-     * @example
-     * ```ts
-     * const { tx } = await account.getPlaceMarketOrderTx({
-     *   marketId: "0x...",
-     *   side: PerpetualsOrderSide.Bid,
-     *   size: BigInt("1000000000"),
-     *   collateralChange: 10,
-     *   reduceOnly: false,
-     * });
-     * ```
-     */
     getPlaceMarketOrderTx(inputs) {
         return __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            const { tx: txFromInputs } = inputs, otherInputs = __rest(inputs, ["tx"]);
-            const tx = txFromInputs !== null && txFromInputs !== void 0 ? txFromInputs : new transactions_1.Transaction();
-            // tx.setSender(this.ownerAddress());
-            return this.fetchApiTxObject(`${this.vaultId ? "vault" : "account"}/` +
-                "transactions/place-market-order", Object.assign(Object.assign(Object.assign({}, otherInputs), { txKind: yield ((_a = this.Provider) === null || _a === void 0 ? void 0 : _a.Transactions().fetchBase64TxKindFromTx({ tx })), walletAddress: this.ownerAddress() }), ("vaultId" in this.accountCap
-                ? {
-                    vaultId: this.accountCap.vaultId,
-                    accountId: undefined,
-                }
-                : {
-                    accountId: this.accountCap.accountId,
-                    accountCapId: this.accountCap.objectId,
-                    vaultId: undefined,
-                })), undefined, {
-                txKind: true,
-            });
+            return this.fetchApiTransaction("transactions/market-order", Object.assign(Object.assign({}, inputs), { accountObjectId: this.accountCap.objectId, accountObjectVersion: this.accountCap.objectVersion, accountObjectDigest: this.accountCap.objectDigest, hasPosition: this.positionForMarketId(inputs) !== undefined }));
         });
     }
-    /**
-     * Build a `place-limit-order` transaction for this account.
-     *
-     * Similar to {@link getPlaceMarketOrderTx}, but uses limit order semantics:
-     * - Requires `price` and `orderType`.
-     * - Supports reduce-only flags, expiry, optional leverage, and SL/TP stop orders.
-     *
-     * Notes:
-     * - `hasPosition` is derived from local account state; refresh the account if needed.
-     * - This method does not validate tick/lot sizing locally; the API/on-chain
-     *   will enforce market constraints.
-     *
-     * @param inputs - See {@link SdkPerpetualsPlaceLimitOrderInputs}.
-     *
-     * @returns Transaction response containing `tx`.
-     */
     getPlaceLimitOrderTx(inputs) {
         return __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            const { tx: txFromInputs } = inputs, otherInputs = __rest(inputs, ["tx"]);
-            const tx = txFromInputs !== null && txFromInputs !== void 0 ? txFromInputs : new transactions_1.Transaction();
-            // tx.setSender(this.ownerAddress());
-            return this.fetchApiTxObject(`${this.vaultId ? "vault" : "account"}/` +
-                "transactions/place-limit-order", Object.assign(Object.assign(Object.assign({}, otherInputs), { txKind: yield ((_a = this.Provider) === null || _a === void 0 ? void 0 : _a.Transactions().fetchBase64TxKindFromTx({ tx })), walletAddress: this.ownerAddress() }), ("vaultId" in this.accountCap
-                ? {
-                    vaultId: this.accountCap.vaultId,
-                    accountId: undefined,
-                }
-                : {
-                    accountId: this.accountCap.accountId,
-                    accountCapId: this.accountCap.objectId,
-                    vaultId: undefined,
-                })), undefined, {
-                txKind: true,
-            });
+            return this.fetchApiTransaction("transactions/limit-order", Object.assign(Object.assign({}, inputs), { accountObjectId: this.accountCap.objectId, accountObjectVersion: this.accountCap.objectVersion, accountObjectDigest: this.accountCap.objectDigest, hasPosition: this.positionForMarketId(inputs) !== undefined }));
         });
     }
-    /**
-     * Build a `cancel-orders` transaction for this account.
-     *
-     * Each market in `marketIdsToData` supplies:
-     * - `orderIds`: the orders to cancel in that market
-     * - `collateralChange`: collateral adjustment to apply alongside cancellation
-     * - `leverage`: leverage context used for estimating/validating constraints server-side
-     *
-     * Notes:
-     * - Cancels are applied per market; some markets may succeed while others fail
-     *   depending on API/on-chain validation (returned as a transaction failure at execution).
-     * - If you need to understand the effect prior to building a tx, use
-     *   {@link getCancelOrdersPreview}.
-     *
-     * @param inputs.tx - Optional transaction to extend.
-     * @param inputs.marketIdsToData - Mapping from market IDs to cancel payloads.
-     *
-     * @returns Transaction response containing `tx`.
-     */
-    getCancelOrdersTx(inputs) {
+    getPlaceSLTPOrder(inputs) {
         return __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            const { tx } = inputs, otherInputs = __rest(inputs, ["tx"]);
-            return this.fetchApiTxObject(`${this.vaultId ? "vault" : "account"}/` +
-                "transactions/cancel-orders", Object.assign(Object.assign(Object.assign({}, otherInputs), { txKind: yield ((_a = this.Provider) === null || _a === void 0 ? void 0 : _a.Transactions().fetchBase64TxKindFromTx({ tx })), walletAddress: this.ownerAddress() }), ("vaultId" in this.accountCap
-                ? {
-                    vaultId: this.accountCap.vaultId,
-                    accountId: undefined,
-                }
-                : {
-                    accountId: this.accountCap.accountId,
-                    accountCapId: this.accountCap.objectId,
-                    vaultId: undefined,
-                })), undefined, {
-                txKind: true,
-            });
+            return this.fetchApiTransaction("transactions/sltp-order", Object.assign(Object.assign({}, inputs), { accountObjectId: this.accountCap.objectId, accountObjectVersion: this.accountCap.objectVersion, accountObjectDigest: this.accountCap.objectDigest }));
         });
     }
-    /**
-     * Build a `cancel-stop-orders` transaction for this account.
-     *
-     * This cancels stop-order *objects/tickets* by their object IDs. These IDs are
-     * returned by stop-order query endpoints (see {@link getStopOrderDatas}).
-     *
-     * @param inputs.tx - Optional transaction to extend.
-     * @param inputs.stopOrderIds - Array of stop-order ticket IDs to cancel.
-     *
-     * @returns Transaction response containing `tx`.
-     */
-    getCancelStopOrdersTx(inputs) {
+    getCancelOrderTx(inputs) {
         return __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            const { tx } = inputs, otherInputs = __rest(inputs, ["tx"]);
-            return this.fetchApiTxObject(`${this.vaultId ? "vault" : "account"}/` +
-                "transactions/cancel-stop-orders", Object.assign(Object.assign(Object.assign({}, otherInputs), { txKind: yield ((_a = this.Provider) === null || _a === void 0 ? void 0 : _a.Transactions().fetchBase64TxKindFromTx({ tx })), walletAddress: this.ownerAddress() }), ("vaultId" in this.accountCap
-                ? {
-                    vaultId: this.accountCap.vaultId,
-                    accountId: undefined,
-                }
-                : {
-                    accountId: this.accountCap.accountId,
-                    accountCapId: this.accountCap.objectId,
-                    vaultId: undefined,
-                })), undefined, {
-                txKind: true,
-            });
+            return this.fetchApiTransaction("transactions/cancel-order", Object.assign(Object.assign({}, inputs), { collateralCoinType: this.accountCap.collateralCoinType, accountCapId: this.accountCap.objectId }));
         });
     }
-    /**
-     * Build a `place-stop-orders` transaction for this account.
-     *
-     * This allows placing one or more stop orders in a single transaction,
-     * optionally with a dedicated gas coin and a sponsored gas flag.
-     *
-     * Typical usage:
-     * - Construct stop order payload(s) client-side
-     * - Call this method to build a transaction kind
-     * - Sign/execute the transaction via Sui
-     *
-     * @param inputs - See {@link SdkPerpetualsPlaceStopOrdersInputs}.
-     *
-     * @returns Transaction response containing `tx`.
-     */
-    getPlaceStopOrdersTx(inputs) {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            const { tx: txFromInputs, isSponsoredTx, stopOrders, gasCoinArg, } = inputs;
-            const tx = txFromInputs !== null && txFromInputs !== void 0 ? txFromInputs : new transactions_1.Transaction();
-            // tx.setSender(this.ownerAddress());
-            return this.fetchApiTxObject(`${this.vaultId ? "vault" : "account"}/` +
-                "transactions/place-stop-orders", Object.assign({ stopOrders,
-                gasCoinArg,
-                isSponsoredTx, txKind: yield ((_a = this.Provider) === null || _a === void 0 ? void 0 : _a.Transactions().fetchBase64TxKindFromTx({ tx })), walletAddress: this.ownerAddress() }, ("vaultId" in this.accountCap
-                ? {
-                    vaultId: this.accountCap.vaultId,
-                    accountId: undefined,
-                }
-                : {
-                    accountId: this.accountCap.accountId,
-                    accountCapId: this.accountCap.objectId,
-                    vaultId: undefined,
-                })), undefined, {
-                txKind: true,
-            });
-        });
-    }
-    /**
-     * Build a `place-sl-tp-orders` transaction for this account.
-     *
-     * This helper constructs SL/TP stop orders for an **existing** position
-     * in a given market. If the account has no position for `marketId`, this
-     * throws an error.
-     *
-     * Implementation details:
-     * - Determines the current position side from the account snapshot.
-     * - Sets `positionSide` for the API so SL/TP orders are bound to closing logic
-     *   (i.e. they should trigger on the opposite side of the open position).
-     *
-     * @param inputs - See {@link SdkPerpetualsPlaceSlTpOrdersInputs}.
-     *
-     * @returns Transaction response containing `tx`.
-     */
-    getPlaceSlTpOrdersTx(inputs) {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            const { tx: txFromInputs, isSponsoredTx, marketId } = inputs, slTpInputs = __rest(inputs, ["tx", "isSponsoredTx", "marketId"]);
-            const position = this.positionForMarketId({ marketId });
-            if (!position)
-                throw new Error("you have no position for this market");
-            const tx = txFromInputs !== null && txFromInputs !== void 0 ? txFromInputs : new transactions_1.Transaction();
-            // tx.setSender(this.ownerAddress());
-            return this.fetchApiTxObject(`${this.vaultId ? "vault" : "account"}/` +
-                "transactions/place-sl-tp-orders", Object.assign(Object.assign(Object.assign(Object.assign({}, slTpInputs), { marketId, txKind: yield ((_a = this.Provider) === null || _a === void 0 ? void 0 : _a.Transactions().fetchBase64TxKindFromTx({ tx })), walletAddress: this.ownerAddress() }), ("vaultId" in this.accountCap
-                ? {
-                    vaultId: this.accountCap.vaultId,
-                    accountId: undefined,
-                }
-                : {
-                    accountId: this.accountCap.accountId,
-                    accountCapId: this.accountCap.objectId,
-                    vaultId: undefined,
-                })), { positionSide: perpetuals_1.Perpetuals.positionSide({
-                    baseAssetAmount: position.baseAssetAmount,
-                }) }), undefined, {
-                txKind: true,
-            });
-        });
-    }
-    /**
-     * Build an `edit-stop-orders` transaction for this account.
-     *
-     * This endpoint lets you update existing stop orders in batch.
-     *
-     * Notes:
-     * - You must provide the full updated stop-order objects (including object IDs).
-     * - This is typically used to adjust trigger prices, sizes, expiries, or the
-     *   embedded limit-order parameters.
-     *
-     * @param inputs.stopOrders - Full updated stop-order payloads to apply.
-     * @param inputs.tx - Optional transaction to extend.
-     *
-     * @returns Transaction response containing `tx`.
-     */
-    getEditStopOrdersTx(inputs) {
+    getCancelOrdersTx(inputs) {
         return __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            const { tx: txFromInputs, stopOrders } = inputs;
-            const tx = txFromInputs !== null && txFromInputs !== void 0 ? txFromInputs : new transactions_1.Transaction();
-            // tx.setSender(this.ownerAddress());
-            return this.fetchApiTxObject(`${this.vaultId ? "vault" : "account"}/` +
-                "transactions/edit-stop-orders", Object.assign({ stopOrders, txKind: yield ((_a = this.Provider) === null || _a === void 0 ? void 0 : _a.Transactions().fetchBase64TxKindFromTx({ tx })), walletAddress: this.ownerAddress() }, ("vaultId" in this.accountCap
-                ? {
-                    vaultId: this.accountCap.vaultId,
-                    accountId: undefined,
-                }
-                : {
-                    accountId: this.accountCap.accountId,
-                    accountCapId: this.accountCap.objectId,
-                    vaultId: undefined,
-                })), undefined, {
-                txKind: true,
-            });
+            return this.fetchApiTransaction("transactions/cancel-orders", Object.assign(Object.assign({}, inputs), { collateralCoinType: this.accountCap.collateralCoinType, accountCapId: this.accountCap.objectId }));
         });
     }
-    // public async getReduceOrderTx(inputs: {
-    // 	tx?: Transaction;
-    // 	collateralChange: number;
-    // 	marketId: PerpetualsMarketId;
-    // 	orderId: PerpetualsOrderId;
-    // 	sizeToSubtract: bigint;
-    // 	leverage?: number;
-    // }) {
-    // 	const { tx, ...otherInputs } = inputs;
-    // 	return this.fetchApiTxObject<
-    // 		ApiPerpetualsReduceOrderBody,
-    // 		ApiTransactionResponse
-    // 	>(
-    // 		`${this.vaultId ? "vault" : "account"}/` +
-    // 			"transactions/reduce-order",
-    // 		{
-    // 			...otherInputs,
-    // 			txKind: await this.Provider?.Transactions().fetchBase64TxKindFromTx(
-    // 				{ tx }
-    // 			),
-    // 			walletAddress: this.ownerAddress(),
-    // 			...("vaultId" in this.accountCap
-    // 				? {
-    // 						vaultId: this.accountCap.vaultId,
-    // accountId: undefined,
-    // 				  }
-    // 				: {
-    // 						accountId: this.accountCap.accountId,
-    // vaultId: undefined,
-    // 				  }),
-    // 		},
-    // 		undefined,
-    // 		{
-    // 			txKind: true,
-    // 		}
-    // 	);
-    // }
-    /**
-     * Build a `set-leverage` transaction for a given market.
-     *
-     * This updates the effective leverage for the position (or potential position)
-     * in `marketId`, and optionally adjusts collateral in tandem.
-     *
-     * Notes:
-     * - Leverage changes may be constrained by protocol risk limits and current
-     *   position state.
-     * - If you want to understand the effect first, use {@link getSetLeveragePreview}.
-     *
-     * @param inputs.tx - Optional transaction to extend.
-     * @param inputs.leverage - Target leverage value.
-     * @param inputs.collateralChange - Net collateral change to apply alongside
-     *   the leverage update.
-     * @param inputs.marketId - Market whose leverage to adjust.
-     *
-     * @returns Transaction response containing `tx`.
-     */
-    getSetLeverageTx(inputs) {
+    getReduceOrdersTx(inputs) {
         return __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            const { leverage, tx, collateralChange, marketId } = inputs;
-            return this.fetchApiTxObject(`${this.vaultId ? "vault" : "account"}/` +
-                "transactions/set-leverage", Object.assign({ leverage,
-                marketId,
-                collateralChange, txKind: yield ((_a = this.Provider) === null || _a === void 0 ? void 0 : _a.Transactions().fetchBase64TxKindFromTx({ tx })), walletAddress: this.ownerAddress() }, ("vaultId" in this.accountCap
-                ? {
-                    vaultId: this.accountCap.vaultId,
-                    accountId: undefined,
-                }
-                : {
-                    accountId: this.accountCap.accountId,
-                    accountCapId: this.accountCap.objectId,
-                    vaultId: undefined,
-                })), undefined, {
-                txKind: true,
-            });
+            const { market, orderDatas } = inputs;
+            return this.fetchApiTransaction("transactions/reduce-orders", Object.assign(Object.assign({}, inputs), { orderIds: orderDatas.map((order) => order.orderId), sizesToSubtract: orderDatas.map((order) => order.sizeToSubtract), packageId: market.marketData.packageId, marketInitialSharedVersion: market.marketData.initialSharedVersion, marketId: market.marketId, basePriceFeedId: market.marketParams.basePriceFeedId, collateralPriceFeedId: market.marketParams.collateralPriceFeedId, collateralCoinType: this.accountCap.collateralCoinType, accountCapId: this.accountCap.objectId }));
         });
     }
     // =========================================================================
     //  Position Txs
     // =========================================================================
-    // public async getClosePositionTx(inputs: {
-    // 	size: bigint;
-    // 	market: PerpetualsMarket;
-    // 	orderDatas: PerpetualsOrderData[];
-    // 	indexPrice: number;
-    // 	collateralPrice: number;
-    // }) {
-    // 	throw new Error("TODO");
-    // 	// return this.getPlaceMarketOrderTx({
-    // 	// 	...this.closePositionTxInputs(inputs),
-    // 	// });
-    // }
+    getClosePositionTx(inputs) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.getPlaceMarketOrderTx(this.closePositionTxInputs(inputs));
+        });
+    }
     // =========================================================================
-    //  Interactions
+    //  Inspections
     // =========================================================================
-    /**
-     * Build a deterministic message payload to sign when querying stop orders
-     * from the backend.
-     *
-     * This payload is intended to be signed off-chain and then submitted to
-     * `getStopOrderDatas` as a proof of account ownership.
-     *
-     * Important:
-     * - The returned payload is *not* a Sui transaction; it is an off-chain
-     *   “authentication” message.
-     * - The backend expects `account_id` to be a decimal string. This code
-     *   normalizes the bigint `accountId` by stripping the trailing `n`.
-     *
-     * @param inputs.marketIds - Optional list of market IDs to scope the query.
-     *
-     * @returns An object describing the action and account/market IDs, suitable
-     *   for message signing.
-     *
-     * @example
-     * ```ts
-     * const message = account.getStopOrdersMessageToSign({ marketIds: ["0x..."] });
-     * const { signature } = await wallet.signMessage({
-     *   message: new TextEncoder().encode(JSON.stringify(message)),
-     * });
-     * ```
-     */
-    getStopOrdersMessageToSign(inputs) {
-        var _a;
-        return {
-            action: "GET_STOP_ORDERS",
-            account_id: this.accountCap.accountId
-                .toString()
-                .replaceAll("n", ""),
-            clearing_house_ids: (_a = inputs === null || inputs === void 0 ? void 0 : inputs.marketIds) !== null && _a !== void 0 ? _a : [],
-        };
+    setPositionLeverage(inputs) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.fetchApi(`${this.accountCap.collateralCoinType}/accounts/${this.accountCap.accountId}/set-position-leverage`, inputs);
+        });
     }
-    // public async getPlaceOrderPreview(
-    // 	inputs: SdkPerpetualsPlaceOrderPreviewInputs,
-    // 	abortSignal?: AbortSignal
-    // ): Promise<
-    // 	| {
-    // 			error: string;
-    // 	  }
-    // 	| {
-    // 			updatedPosition: PerpetualsPosition;
-    // 			priceSlippage: number;
-    // 			percentSlippage: Percentage;
-    // 			filledSize: number;
-    // 			filledSizeUsd: number;
-    // 			postedSize: number;
-    // 			postedSizeUsd: number;
-    // 			collateralChange: number;
-    // 			executionPrice: number;
-    // 	  }
+    // public async getAllPositionLeverages(): Promise<
+    // 	{
+    // 		marketId: PerpetualsMarketId;
+    // 		leverage: number;
+    // 	}[]
     // > {
-    // 	return this.fetchApi<
-    // 		ApiPerpetualsPreviewOrderResponse,
-    // 		ApiPerpetualsPreviewOrderBody
-    // 	>(
-    // 		`${this.vaultId ? "vault" : "account"}/` +"previews/place-order",
-    // 		{
-    // 			...inputs,
-    // 			accountId: this.accountCap.accountId,
-    // 			collateralCoinType: this.accountCap.collateralCoinType,
-    // 		},
-    // 		abortSignal
+    // 	return this.fetchApi(
+    // 		`${this.accountCap.collateralCoinType}/accounts/${this.accountCap.accountId}/position-leverages`
     // 	);
     // }
-    /**
-     * Preview the effects of placing a market order (without building a tx).
-     *
-     * This is a read-only API call that runs the protocol’s pricing / margin /
-     * slippage logic against the current market state and your account/vault context.
-     *
-     * @param inputs - See {@link SdkPerpetualsPlaceMarketOrderPreviewInputs}.
-     * @param abortSignal - Optional `AbortSignal` to cancel the request.
-     *
-     * @returns Either an error message or a preview including:
-     * - `updatedPosition`
-     * - `priceSlippage`, `percentSlippage`
-     * - `filledSize`, `filledSizeUsd`
-     * - `postedSize`, `postedSizeUsd`
-     * - `collateralChange`
-     * - `executionPrice`
-     */
-    getPlaceMarketOrderPreview(inputs, abortSignal) {
+    getPositionLeverages(inputs) {
         return __awaiter(this, void 0, void 0, function* () {
-            return this.fetchApi(`${this.vaultId ? "vault" : "account"}/` +
-                "previews/place-market-order", Object.assign(Object.assign({}, inputs), ("vaultId" in this.accountCap
-                ? {
-                    vaultId: this.accountCap.vaultId,
-                    accountId: undefined,
-                }
-                : {
-                    accountId: this.accountCap.accountId,
-                    accountCapId: this.accountCap.objectId,
-                    vaultId: undefined,
-                })), abortSignal);
+            return this.fetchApi(`${this.accountCap.collateralCoinType}/accounts/${this.accountCap.accountId}/position-leverages/${JSON.stringify(inputs.marketIds)}`);
         });
     }
-    /**
-     * Preview the effects of placing a limit order (without building a tx).
-     *
-     * The preview simulates:
-     * - How much size would execute immediately vs post to the book
-     * - Expected slippage and execution price
-     * - Resulting position and margin impact
-     *
-     * @param inputs - See {@link SdkPerpetualsPlaceLimitOrderPreviewInputs}.
-     * @param abortSignal - Optional `AbortSignal` to cancel the request.
-     *
-     * @returns Either an error message or a preview object similar to
-     *   {@link getPlaceMarketOrderPreview}.
-     */
-    getPlaceLimitOrderPreview(inputs, abortSignal) {
+    setPositionLeverageMessageToSign(inputs) {
+        return {
+            account_id: Number(this.accountCap.accountId),
+            market_id: inputs.marketId,
+            leverage: inputs.leverage,
+        };
+    }
+    getOrderPreview(inputs, abortSignal) {
         return __awaiter(this, void 0, void 0, function* () {
-            return this.fetchApi(`${this.vaultId ? "vault" : "account"}/` +
-                "previews/place-limit-order", Object.assign(Object.assign({}, inputs), ("vaultId" in this.accountCap
-                ? {
-                    vaultId: this.accountCap.vaultId,
-                    accountId: undefined,
-                }
-                : {
-                    accountId: this.accountCap.accountId,
-                    accountCapId: this.accountCap.objectId,
-                    vaultId: undefined,
-                })), abortSignal);
+            const response = yield this.fetchApi("preview-order", Object.assign(Object.assign({}, inputs), { accountId: this.accountCap.accountId, collateralCoinType: this.accountCap.collateralCoinType }), abortSignal);
+            if ("error" in response)
+                return response;
+            const { collateralChange } = response, remainingResponse = __rest(response, ["collateralChange"]);
+            return Object.assign(Object.assign({}, remainingResponse), { collateralChange: __1.Coin.normalizeBalance(collateralChange, this.collateralDecimals()) });
         });
     }
-    /**
-     * Preview the effects of canceling orders across one or more markets.
-     *
-     * This is commonly used to:
-     * - Validate that cancels are allowed under current margin constraints
-     * - Estimate how collateral/margin would change after canceling (and applying
-     *   the associated `collateralChange` values)
-     *
-     * If `marketIdsToData` is empty, this returns a trivial preview with:
-     * - `marketIdsToData: {}`
-     *
-     * @param inputs - See {@link SdkPerpetualsCancelOrdersPreviewInputs}.
-     * @param abortSignal - Optional `AbortSignal` to cancel the request.
-     *
-     * @returns Either:
-     * - `{ marketIdsToData }`, or
-     * - `{ error }`.
-     */
-    getCancelOrdersPreview(inputs, abortSignal) {
+    getCancelOrdersPreview(inputs) {
         return __awaiter(this, void 0, void 0, function* () {
             // NOTE: should this case return an error instead ?
             if (Object.keys(inputs.marketIdsToData).length <= 0)
                 return {
-                    marketIdsToData: {},
+                    collateralChange: BigInt(0),
+                    marketIdsToPositionAfterCancelOrders: {},
                 };
-            return this.fetchApi(`${this.vaultId ? "vault" : "account"}/` + "previews/cancel-orders", Object.assign(Object.assign({}, inputs), ("vaultId" in this.accountCap
-                ? {
-                    vaultId: this.accountCap.vaultId,
-                    accountId: undefined,
-                }
-                : {
-                    accountId: this.accountCap.accountId,
-                    accountCapId: this.accountCap.objectId,
-                    vaultId: undefined,
-                })), abortSignal);
-        });
-    }
-    // public async getReduceOrderPreview(
-    // 	inputs: {
-    // 		marketId: PerpetualsMarketId;
-    // 		orderId: PerpetualsOrderId;
-    // 		sizeToSubtract: bigint;
-    // 		leverage?: number;
-    // 	},
-    // 	abortSignal?: AbortSignal
-    // ): Promise<
-    // 	| {
-    // 			positionAfterReduceOrder: PerpetualsPosition;
-    // 			collateralChange: number;
-    // 	  }
-    // 	| {
-    // 			error: string;
-    // 	  }
-    // > {
-    // 	return this.fetchApi<
-    // 		ApiPerpetualsPreviewReduceOrderResponse,
-    // 		ApiPerpetualsPreviewReduceOrderBody
-    // 	>(
-    // 		`${this.vaultId ? "vault" : "account"}/` + "previews/reduce-order",
-    // 		{
-    // 			...inputs,
-    // 			...("vaultId" in this.accountCap
-    // 				? {
-    // 						vaultId: this.accountCap.vaultId,
-    //						accountId: undefined,
-    // 				  }
-    // 				: {
-    // 						accountId: this.accountCap.accountId,
-    //						vaultId: undefined,
-    // 				  }),
-    // 		},
-    // 		abortSignal
-    // 	);
-    // }
-    /**
-     * Preview the effects of setting leverage for a given market.
-     *
-     * The preview returns:
-     * - The position after the leverage change (`updatedPosition`)
-     * - The collateral delta required/produced (`collateralChange`)
-     *
-     * @param inputs.marketId - Market whose leverage you want to adjust.
-     * @param inputs.leverage - Target leverage value.
-     * @param abortSignal - Optional `AbortSignal` to cancel the request.
-     *
-     * @returns Either:
-     * - `{ updatedPosition, collateralChange }`, or
-     * - `{ error }`.
-     */
-    getSetLeveragePreview(inputs, abortSignal) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { marketId, leverage } = inputs;
-            return this.fetchApi(`${this.vaultId ? "vault" : "account"}/` + "previews/set-leverage", Object.assign({ marketId,
-                leverage }, ("vaultId" in this.accountCap
-                ? {
-                    vaultId: this.accountCap.vaultId,
-                    accountId: undefined,
-                }
-                : {
-                    accountId: this.accountCap.accountId,
-                    accountCapId: this.accountCap.objectId,
-                    vaultId: undefined,
-                })), abortSignal);
+            const response = yield this.fetchApi("preview-cancel-orders", Object.assign(Object.assign({}, inputs), { accountId: this.accountCap.accountId, collateralCoinType: this.accountCap.collateralCoinType }));
+            if ("error" in response)
+                return response;
+            return {
+                marketIdsToPositionAfterCancelOrders: response.marketIdsToPositionAfterCancelOrders,
+                collateralChange: __1.Coin.normalizeBalance(response.collateralChange, this.collateralDecimals()),
+            };
         });
     }
-    /**
-     * Preview the effects of allocating/deallocating collateral for the position in
-     * a given market.
-     *
-     * Semantics:
-     * - Positive `collateralChange` previews allocation (moving collateral into the market).
-     * - Negative `collateralChange` previews deallocation (moving collateral out of the market).
-     *
-     * @param inputs.marketId - Market of whose position you want to allocate/deallocate
-     * collateral to/from.
-     * @param inputs.collateralChange - The target collateral change (a positive number
-     * for allocating collateral, negative for deallocating collateral).
-     * @param abortSignal - Optional `AbortSignal` to cancel the request.
-     *
-     * @returns Either:
-     * - `{ updatedPosition, collateralChange }`, or
-     * - `{ error }`.
-     */
-    getEditCollateralPreview(inputs, abortSignal) {
+    getReduceOrdersPreview(inputs) {
         return __awaiter(this, void 0, void 0, function* () {
-            const { marketId, collateralChange } = inputs;
-            return this.fetchApi(`${this.vaultId ? "vault" : "account"}/` +
-                "previews/edit-collateral", Object.assign({ marketId,
-                collateralChange }, ("vaultId" in this.accountCap
-                ? {
-                    vaultId: this.accountCap.vaultId,
-                    accountId: undefined,
-                }
-                : {
-                    accountId: this.accountCap.accountId,
-                    accountCapId: this.accountCap.objectId,
-                    vaultId: undefined,
-                })), abortSignal);
+            // NOTE: should this case not throw an error instead ?
+            if (Object.keys(inputs.orderDatas).length <= 0)
+                throw new Error("no orderDatas provided");
+            const response = yield this.fetchApi("preview-reduce-orders", Object.assign(Object.assign({}, inputs), { orderIds: inputs.orderDatas.map((order) => order.orderId), sizesToSubtract: inputs.orderDatas.map((order) => order.sizeToSubtract), accountId: this.accountCap.accountId, collateralCoinType: this.accountCap.collateralCoinType }));
+            if ("error" in response)
+                return response;
+            return {
+                positionAfterReduceOrders: response.positionAfterReduceOrders,
+                collateralChange: __1.Coin.normalizeBalance(response.collateralChange, this.collateralDecimals()),
+            };
         });
     }
-    // public getPlaceClosePositionOrderPreview = async (
-    // 	inputs: {
-    // 		size: bigint;
-    // 		marketId: PerpetualsMarketId;
-    // 		leverage?: number;
-    // 	} & (
-    // 		| {
-    // 				accountId: PerpetualsAccountId;
-    // 		  }
-    // 		| {
-    // 				vaultId: ObjectId;
-    // 		  }
-    // 	),
-    // 	abortSignal?: AbortSignal
-    // ): Promise<ReturnType<PerpetualsAccount["getPlaceMarketOrderPreview"]>> => {
-    // 	// TODO: make this fetch instead ?
-    // 	const position = this.positionForMarketId({
-    // 		marketId: inputs.marketId,
-    // 	});
-    // 	if (!position)
-    // 		throw new Error(
-    // 			`Account has no position for market id: ${inputs.marketId}`
-    // 		);
-    // 	return this.getPlaceMarketOrderPreview(
-    // 		{
-    // 			...inputs,
-    // 			reduceOnly: true,
-    // 			side:
-    // 				Perpetuals.positionSide(position) ===
-    // 				PerpetualsOrderSide.Ask
-    // 					? PerpetualsOrderSide.Bid
-    // 					: PerpetualsOrderSide.Ask,
-    // 		},
-    // 		abortSignal
-    // 	);
-    // };
-    /**
-     * Fetch stop-order ticket data for this account, using an off-chain signed
-     * payload.
-     *
-     * Typical flow:
-     * 1) Call {@link getStopOrdersMessageToSign} to construct a deterministic payload
-     * 2) Sign the payload with the wallet
-     * 3) Provide the signed payload to this method to fetch stop order data
-     *
-     * @param inputs.bytes - Serialized message that was signed (e.g. JSON string).
-     * @param inputs.signature - Signature over `bytes`.
-     * @param inputs.marketIds - Optional subset of markets to filter results by.
-     *
-     * @returns {@link ApiPerpetualsStopOrderDatasResponse} containing `stopOrderDatas`.
-     */
-    getStopOrderDatas(inputs) {
+    getOrderDatas() {
         return __awaiter(this, void 0, void 0, function* () {
-            const { bytes, signature, marketIds } = inputs;
-            return this.fetchApi(`${this.vaultId ? "vault" : "account"}/` + "stop-order-datas", Object.assign({ bytes,
-                signature, walletAddress: this.ownerAddress(), marketIds: marketIds !== null && marketIds !== void 0 ? marketIds : [] }, ("vaultId" in this.accountCap
-                ? {
-                    vaultId: this.accountCap.vaultId,
-                    accountId: undefined,
-                }
-                : {
-                    accountId: this.accountCap.accountId,
-                    accountCapId: this.accountCap.objectId,
-                    vaultId: undefined,
-                })));
+            const orderDatas = this.account.positions.reduce((acc, position) => [
+                ...acc,
+                ...position.pendingOrders.map((order) => ({
+                    orderId: order.orderId,
+                    currentSize: order.size,
+                })),
+            ], []);
+            if (orderDatas.length <= 0)
+                return [];
+            return this.fetchApi(`${this.accountCap.collateralCoinType}/accounts/${this.accountCap.accountId}/order-datas`, {
+                orderDatas,
+            });
         });
     }
-    /**
-     * Fetch paginated collateral-change history for this account, including
-     * deposits, withdrawals, funding settlements, liquidations, etc.
-     *
-     * Pagination:
-     * - Use `beforeTimestampCursor` to fetch older entries.
-     * - The API returns a `nextBeforeTimestampCursor` to continue pagination.
-     *
-     * @param inputs.beforeTimestampCursor - Optional cursor for pagination.
-     * @param inputs.limit - Optional limit per page.
-     *
-     * @returns {@link ApiPerpetualsAccountCollateralHistoryResponse} containing
-     * an array of changes and a `nextBeforeTimestampCursor`.
-     */
     getCollateralHistory(inputs) {
         return __awaiter(this, void 0, void 0, function* () {
-            return this.fetchApi("account/collateral-history", Object.assign(Object.assign({}, inputs), { accountId: this.accountCap.accountId }));
+            return this.fetchApi(`${this.accountCap.collateralCoinType}/accounts/${this.accountCap.accountId}/collateral-history`, inputs);
         });
     }
-    /**
-     * Fetch paginated order history for this account.
-     *
-     * This endpoint is distinct from {@link getOrderDatas}:
-     * - `getOrderDatas` resolves current/pending orders based on the snapshot.
-     * - `getOrderHistory` returns historical order events (fills, cancels, etc.)
-     *   over time with cursor-based pagination.
-     *
-     * @param inputs.beforeTimestampCursor - Optional cursor for pagination.
-     * @param inputs.limit - Optional limit per page.
-     *
-     * @returns {@link ApiPerpetualsAccountOrderHistoryResponse} containing a list of
-     * orders and a `nextBeforeTimestampCursor`.
-     */
     getOrderHistory(inputs) {
         return __awaiter(this, void 0, void 0, function* () {
-            return this.fetchApi("account/order-history", Object.assign(Object.assign({}, inputs), { accountId: this.accountCap.accountId }));
-        });
-    }
-    /**
-     * Fetch historical margin snapshots for this account over a time range.
-     *
-     * This endpoint returns time-series margin data suitable for charting UI
-     * such as equity and available collateral over time.
-     *
-     * Notes:
-     * - This is an account-level view (aggregated across markets).
-     *
-     * @param inputs - {@link ApiPerpetualsAccountMarginHistoryBody} without `accountId`.
-     * @returns {@link ApiPerpetualsAccountMarginHistoryResponse} containing `marginHistoryDatas`.
-     */
-    getMarginHistory(inputs) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.fetchApi("account/margin-history", Object.assign(Object.assign({}, inputs), { accountId: this.accountCap.accountId }));
-        });
-    }
-    // public async getOwnedWithdrawRequests() {
-    // 	return new Perpetuals(
-    // 		this.config,
-    // 		this.Provider
-    // 	).getOwnedWithdrawRequests({
-    // 		walletAddress: this.ownerAddress(),
-    // 	});
-    // }
-    /**
-     * Build a transaction that grants an Agent Wallet (assistant permissions) for this perpetuals account.
-     *
-     * The returned transaction must be signed and submitted by the **account admin** wallet.
-     * After execution, `recipientAddress` can execute supported trading actions on behalf of this account.
-     *
-     * Agent wallets can perform all supported actions **except**:
-     * - withdrawing collateral, and
-     * - granting or revoking other agent wallets.
-     *
-     * @param inputs.recipientAddress Wallet address to receive agent permissions.
-     * @param inputs.tx Optional existing {@link Transaction} to append to. If omitted, a new Transaction is used.
-     * @throws If this instance represents a vault account (agent wallets are account-only).
-     */
-    getGrantAgentWalletTx(inputs) {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            const { tx, recipientAddress } = inputs;
-            if ("vaultId" in this.accountCap)
-                throw new Error("`getGrantAgentWalletTx` not supported by vault accounts");
-            return this.fetchApiTxObject("account/transactions/grant-agent-wallet", {
-                recipientAddress,
-                accountId: this.accountCap.accountId,
-                txKind: yield ((_a = this.Provider) === null || _a === void 0 ? void 0 : _a.Transactions().fetchBase64TxKindFromTx({
-                    tx: tx !== null && tx !== void 0 ? tx : new transactions_1.Transaction(),
-                })),
-            }, undefined, {
-                txKind: true,
-            });
-        });
-    }
-    /**
-     * Build a transaction that revokes an Agent Wallet (assistant capability) from this perpetuals account.
-     *
-     * The returned transaction must be signed and submitted by the **account admin** wallet.
-     * After execution, the revoked wallet immediately loses its delegated permissions.
-     *
-     * @param inputs.accountCapId Object ID of the assistant capability to revoke.
-     * @param inputs.tx Optional existing {@link Transaction} to append to. If omitted, a new Transaction is used.
-     * @throws If this instance represents a vault account (agent wallets are account-only).
-     */
-    getRevokeAgentWalletTx(inputs) {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            const { tx, accountCapId } = inputs;
-            if ("vaultId" in this.accountCap)
-                throw new Error("`getRevokeAgentWalletTx` not supported by vault accounts");
-            return this.fetchApiTxObject("account/transactions/revoke-agent-wallet", {
-                accountCapId,
-                accountId: this.accountCap.accountId,
-                txKind: yield ((_a = this.Provider) === null || _a === void 0 ? void 0 : _a.Transactions().fetchBase64TxKindFromTx({
-                    tx: tx !== null && tx !== void 0 ? tx : new transactions_1.Transaction(),
-                })),
-            }, undefined, {
-                txKind: true,
-            });
+            return this.fetchApi(`${this.accountCap.collateralCoinType}/accounts/${this.accountCap.accountId}/order-history`, inputs);
         });
     }
     // =========================================================================
     //  Helpers
     // =========================================================================
-    /**
-     * Find the current position for a given market ID, if any.
-     *
-     * @param inputs.marketId - Market ID to search for.
-     * @returns {@link PerpetualsPosition} if found, otherwise `undefined`.
-     */
     positionForMarketId(inputs) {
         try {
             return this.account.positions.find((pos) => pos.marketId === inputs.marketId);
@@ -1133,271 +429,20 @@ class PerpetualsAccount extends caller_1.Caller {
             return undefined;
         }
     }
-    /**
-     * Filter a list of stop orders to only include non-SL/TP orders.
-     *
-     * A stop order is considered SL/TP if it appears in the combined set of
-     * SL/TP orders across **all** markets (see {@link slTpStopOrderDatas}).
-     *
-     * Note:
-     * - This implementation uses JSON string equality to compare objects.
-     *   This is pragmatic but assumes stable field ordering and identical shapes.
-     *
-     * @param inputs.stopOrderDatas - Full array of stop-order ticket data.
-     * @returns An array of non-SL/TP stop orders, or `undefined` if none exist.
-     */
-    nonSlTpStopOrderDatas(inputs) {
-        const { stopOrderDatas } = inputs;
-        const slTpOrders = this.slTpStopOrderDatas(inputs);
-        const stopOrders = stopOrderDatas.filter((stopOrder) => !(slTpOrders !== null && slTpOrders !== void 0 ? slTpOrders : [])
-            .map((slTpOrder) => JSON.stringify(slTpOrder))
-            .includes(JSON.stringify(stopOrder)));
-        return stopOrders.length <= 0 ? undefined : stopOrders;
-    }
-    /**
-     * Extract all SL/TP-style stop orders across **all** markets for this
-     * account.
-     *
-     * SL/TP orders are stop orders which:
-     * - Have an `slTp` payload, and
-     * - Target the opposite side of the current position.
-     *
-     * This combines:
-     * - "Full" SL/TP orders (size >= `i64MaxBigInt`)
-     * - "Partial" SL/TP orders (size < `i64MaxBigInt`)
-     *
-     * The "full vs partial" distinction is a protocol convention: some systems
-     * encode “close entire position” using a sentinel max size.
-     *
-     * @param inputs.stopOrderDatas - Full list of stop-order tickets.
-     * @returns Array of SL/TP stop orders, or `undefined` if none exist.
-     */
-    slTpStopOrderDatas(inputs) {
-        const { stopOrderDatas } = inputs;
-        let slTpOrders = [];
-        for (const { marketId } of this.account.positions) {
-            const { fullSlTpOrder, partialSlTpOrders } = this.slTpStopOrderDatasForPosition({
-                marketId,
-                stopOrderDatas,
-            });
-            slTpOrders = [
-                ...slTpOrders,
-                ...(fullSlTpOrder ? [fullSlTpOrder] : []),
-                ...(partialSlTpOrders !== null && partialSlTpOrders !== void 0 ? partialSlTpOrders : []),
-            ];
-        }
-        for (const limitOrderId of utils_1.Helpers.uniqueArray(stopOrderDatas.map((stopOrder) => { var _a; return (_a = stopOrder.slTp) === null || _a === void 0 ? void 0 : _a.limitOrderId; }))) {
-            if (limitOrderId === undefined)
-                continue;
-            const { fullSlTpOrder, partialSlTpOrders } = this.slTpStopOrderDatasForLimitOrder({
-                limitOrderId,
-                stopOrderDatas,
-            });
-            slTpOrders = [
-                ...slTpOrders,
-                ...(fullSlTpOrder ? [fullSlTpOrder] : []),
-                ...(partialSlTpOrders !== null && partialSlTpOrders !== void 0 ? partialSlTpOrders : []),
-            ];
-        }
-        return slTpOrders.length <= 0 ? undefined : slTpOrders;
-    }
-    /**
-     * Filter stop orders for a single market to only include non-SL/TP orders.
-     *
-     * Uses {@link slTpStopOrderDatasForPosition} under the hood.
-     *
-     * @param inputs.marketId - Market ID to filter for.
-     * @param inputs.stopOrderDatas - Full list of stop orders.
-     * @returns Non-SL/TP stop orders for the given market, or `undefined` if none exist.
-     */
-    nonSlTpStopOrderDatasForPosition(inputs) {
-        const { marketId, stopOrderDatas } = inputs;
-        const position = this.positionForMarketId({ marketId });
-        if (!position)
-            return undefined;
-        const { fullSlTpOrder, partialSlTpOrders } = this.slTpStopOrderDatasForPosition(inputs);
-        const stopOrders = stopOrderDatas.filter((stopOrder) => ![
-            ...(fullSlTpOrder ? [fullSlTpOrder] : []),
-            ...(partialSlTpOrders !== null && partialSlTpOrders !== void 0 ? partialSlTpOrders : []),
-        ]
-            .map((slTpOrder) => JSON.stringify(slTpOrder))
-            .includes(JSON.stringify(stopOrder)));
-        return stopOrders.length <= 0 ? undefined : stopOrders;
-    }
-    /**
-     * Categorize stop orders for a specific market into:
-     * - A "full" SL/TP order (size >= `i64MaxBigInt`) if any.
-     * - A set of "partial" SL/TP orders (size < `i64MaxBigInt`).
-     *
-     * SL/TP stop orders are defined as:
-     * - Market ID matches the input market.
-     * - `slTp` field is present.
-     * - Order side is opposite of the position side.
-     * - At least a `stopLossIndexPrice` or `takeProfitIndexPrice` is set.
-     *
-     * Notes on matching:
-     * - The side comparison uses the current position side derived from the account snapshot.
-     * - If `baseAssetAmount === 0` (no effective position), the method returns no SL/TP orders.
-     *
-     * @param inputs.marketId - Market to categorize stop orders for.
-     * @param inputs.stopOrderDatas - Full list of stop orders.
-     *
-     * @returns Object containing:
-     * - `fullSlTpOrder` (if any)
-     * - `partialSlTpOrders` (if any, otherwise `undefined`)
-     */
-    slTpStopOrderDatasForPosition(inputs) {
-        const { marketId, stopOrderDatas } = inputs;
-        const position = this.positionForMarketId({ marketId });
-        if (!position || position.baseAssetAmount === 0) {
-            return {
-                fullSlTpOrder: undefined,
-                partialSlTpOrders: undefined,
-            };
-        }
-        const side = !position ? undefined : perpetuals_1.Perpetuals.positionSide(position);
-        /**
-         * Implementation note:
-         *
-         * This method uses a pair of predicates that differ only by the `size` threshold
-         * to split “full close” SL/TP from “partial close” SL/TP. The sentinel threshold
-         * is {@link Casting.i64MaxBigInt}. Keeping the logic explicit (rather than
-         * abstracting into helpers) makes it easier to reason about protocol conventions.
-         */
-        const fullSlTpOrder = stopOrderDatas.find((order) => order.marketId === marketId &&
-            order.slTp &&
-            order.side !== side &&
-            (order.slTp.stopLossIndexPrice ||
-                order.slTp.takeProfitIndexPrice) &&
-            order.size >= utils_1.Casting.i64MaxBigInt);
-        const partialSlTpOrders = stopOrderDatas.filter((order) => order.marketId === marketId &&
-            order.slTp &&
-            order.side !== side &&
-            (order.slTp.stopLossIndexPrice ||
-                order.slTp.takeProfitIndexPrice) &&
-            order.size < utils_1.Casting.i64MaxBigInt);
-        return {
-            fullSlTpOrder,
-            partialSlTpOrders: partialSlTpOrders.length <= 0 ? undefined : partialSlTpOrders,
-        };
-    }
-    slTpStopOrderDatasForLimitOrder(inputs) {
-        const { stopOrderDatas, limitOrderId } = inputs;
-        /**
-         * Implementation note:
-         *
-         * This method uses a pair of predicates that differ only by the `size` threshold
-         * to split “full close” SL/TP from “partial close” SL/TP. The sentinel threshold
-         * is {@link Casting.i64MaxBigInt}. Keeping the logic explicit (rather than
-         * abstracting into helpers) makes it easier to reason about protocol conventions.
-         */
-        const fullSlTpOrder = stopOrderDatas.find((order) => order.slTp &&
-            order.slTp.limitOrderId === limitOrderId &&
-            (order.slTp.stopLossIndexPrice ||
-                order.slTp.takeProfitIndexPrice) &&
-            order.size >= utils_1.Casting.i64MaxBigInt);
-        const partialSlTpOrders = stopOrderDatas.filter((order) => order.slTp &&
-            order.slTp.limitOrderId === limitOrderId &&
-            (order.slTp.stopLossIndexPrice ||
-                order.slTp.takeProfitIndexPrice) &&
-            order.size < utils_1.Casting.i64MaxBigInt);
-        return {
-            fullSlTpOrder,
-            partialSlTpOrders: partialSlTpOrders.length <= 0 ? undefined : partialSlTpOrders,
-        };
-    }
-    orderDatas() {
-        return this.account.positions.reduce((acc, position) => [
-            ...acc,
-            ...position.pendingOrders.map((order) => ({
-                orderId: order.orderId,
-                currentSize: order.currentSize,
-                initialSize: order.initialSize,
-                side: perpetuals_1.Perpetuals.orderIdToSide(order.orderId),
-                marketId: position.marketId,
-            })),
-        ], []);
-    }
-    /**
-     * Convenience accessor for the account's available collateral (in coin units).
-     *
-     * This is the amount of collateral not currently locked/allocated across markets,
-     * as represented by the backend response.
-     *
-     * @returns Available collateral as a `number`.
-     */
     collateral() {
-        return this.account.availableCollateral;
+        return utils_1.Casting.IFixed.numberFromIFixed(this.accountCap.collateral);
     }
-    // public collateralDecimals(): CoinDecimal {
-    // 	return this.accountCap.collateralDecimals;
-    // }
-    // public collateralBalance(): Balance {
-    // 	return Coin.normalizeBalance(
-    // 		this.collateral(),
-    // 		this.collateralDecimals()
-    // 	);
-    // }
-    /**
-     * Check whether this {@link PerpetualsAccount} is vault-backed.
-     *
-     * @returns `true` if the underlying `accountCap` is a vault cap; otherwise `false`.
-     */
-    isVault() {
-        return "vaultId" in this.accountCap;
+    collateralDecimals() {
+        return this.accountCap.collateralDecimals;
     }
-    /**
-     * Resolve the owner wallet address of this account or vault.
-     *
-     * - For direct accounts, returns the cap's `walletAddress` field.
-     * - For vault-backed accounts, returns the vault cap's `ownerAddress`.
-     *
-     * Naming note:
-     * - Some types use `walletAddress` for direct ownership. For vault-backed accounts
-     *   the analogous field is `ownerAddress`.
-     *
-     * @returns Owner wallet {@link SuiAddress}.
-     */
-    ownerAddress() {
-        return "walletAddress" in this.accountCap
-            ? // NOTE: direct accounts expose `walletAddress`; vault accounts expose `ownerAddress`.
-                this.accountCap.walletAddress
-            : this.accountCap.ownerAddress;
-    }
-    /**
-     * Get the underlying account object ID.
-     *
-     * This is the on-chain object that holds the account's state and positions.
-     *
-     * @returns {@link ObjectId} of the account object.
-     */
-    accountObjectId() {
-        return this.accountCap.accountObjectId;
-    }
-    /**
-     * Get the numeric perpetuals account ID.
-     *
-     * This is the protocol-level identifier (bigint-derived) used across API calls.
-     *
-     * @returns {@link PerpetualsAccountId} for this account.
-     */
-    accountId() {
-        return this.accountCap.accountId;
-    }
-    /**
-     * Get the account cap object ID, if this is a direct account.
-     *
-     * Direct accounts are controlled via an on-chain “cap” object. Vault-backed
-     * accounts are controlled via vault caps and do not expose a direct account-cap ID.
-     *
-     * @throws If called for a vault-backed account.
-     *
-     * @returns {@link ObjectId} of the account cap.
-     */
-    accountCapId() {
-        if ("vaultId" in this.accountCap)
-            throw new Error("not account cap id present on vault owned account");
-        return this.accountCap.objectId;
+    collateralBalance() {
+        return __1.Coin.normalizeBalance(this.collateral(), this.collateralDecimals());
     }
 }
 exports.PerpetualsAccount = PerpetualsAccount;
+// =========================================================================
+//  Private Constants
+// =========================================================================
+PerpetualsAccount.constants = {
+    closePositionMarginOfError: 0.1, // 10%
+};