@velocity-exchange/sdk 0.8.0 → 0.9.0

package/lib/browser/idl/velocity.json

@@ -12460,6 +12460,10 @@
                 {
                     "name": "equity_floor",
                     "type": "u64"
+                },
+                {
+                    "name": "equity_floor_buffer",
+                    "type": "u64"
                 }
             ]
         },
@@ -12881,6 +12885,63 @@
             ],
             "args": []
         },
+        {
+            "name": "update_user_vault_owned",
+            "docs": [
+                "Mark a User as vault-owned (its authority is a vault PDA and its equity",
+                "prices vault depositor shares). Set-only and authority-gated: only the",
+                "User's authority may call it, and it is CPI'd by the vaults program at",
+                "vault init. A vault-owned User is skipped by the revenue-share sweep so a",
+                "builder/referral reward can never enter vault NAV (OtterSec #91/#92/#93)."
+            ],
+            "discriminator": [
+                50,
+                156,
+                218,
+                143,
+                216,
+                94,
+                68,
+                93
+            ],
+            "accounts": [
+                {
+                    "name": "user",
+                    "writable": true,
+                    "pda": {
+                        "seeds": [
+                            {
+                                "kind": "const",
+                                "value": [
+                                    117,
+                                    115,
+                                    101,
+                                    114
+                                ]
+                            },
+                            {
+                                "kind": "account",
+                                "path": "authority"
+                            },
+                            {
+                                "kind": "arg",
+                                "path": "sub_account_id"
+                            }
+                        ]
+                    }
+                },
+                {
+                    "name": "authority",
+                    "signer": true
+                }
+            ],
+            "args": [
+                {
+                    "name": "_sub_account_id",
+                    "type": "u16"
+                }
+            ]
+        },
         {
             "name": "update_warm_admin",
             "discriminator": [
@@ -16293,6 +16354,16 @@
             "code": 6364,
             "name": "DailyDepositLimit",
             "msg": "Spot market daily deposit limit hit"
+        },
+        {
+            "code": 6365,
+            "name": "ReservedSpotMarketName",
+            "msg": "The name 'USDT' is reserved for the quote spot market (index 0)"
+        },
+        {
+            "code": 6366,
+            "name": "CannotModifyBuilderOrder",
+            "msg": "Cannot modify a builder-coded order; cancel and re-place instead"
         }
     ],
     "types": [
@@ -24059,21 +24130,24 @@
                     {
                         "name": "equity_floor",
                         "docs": [
-                            "Minimum account equity (cross-margin total collateral) required for",
-                            "risk-increasing orders, fills, withdrawals and deposit transfers.",
-                            "Settable only by the warm/cold admin; 0 disables the check.",
+                            "Minimum account equity (cross-margin total collateral). Below this the",
+                            "permissionless breaker can trip. Risk-increasing orders, fills,",
+                            "withdrawals and deposit transfers must clear `equity_floor +",
+                            "equity_floor_buffer`. Settable only by the warm/cold admin; 0 disables",
+                            "both checks.",
                             "precision: QUOTE_PRECISION"
                         ],
                         "type": "u64"
                     },
                     {
-                        "name": "padding2",
-                        "type": {
-                            "array": [
-                                "u8",
-                                8
-                            ]
-                        }
+                        "name": "equity_floor_buffer",
+                        "docs": [
+                            "Extra headroom above `equity_floor` required by risk-increasing",
+                            "actions, so an account cannot legally end an action at the trip",
+                            "threshold. No effect while `equity_floor` is 0.",
+                            "precision: QUOTE_PRECISION"
+                        ],
+                        "type": "u64"
                     }
                 ]
             }

package/lib/browser/index.d.ts

@@ -45,6 +45,7 @@ export * from './adminClient';
 export * from './assert/assert';
 export { PythLazerSubscriber, type PythLazerPriceFeedArray, type PriceUpdateAccount, } from './pyth';
 export * from './testClient';
+export * from './equityFloorManager';
 export * from './user';
 export * from './userConfig';
 export * from './userStats';
@@ -109,6 +110,7 @@ export * from './tx/priorityFeeCalculator';
 export * from './tx/types';
 export * from './tx/txHandler';
 export * from './tx/txParamProcessor';
+export * from './tx/utils';
 export * from './util/computeUnits';
 export * from './util/digest';
 export * from './util/promiseTimeout';

package/lib/browser/index.js

@@ -75,6 +75,7 @@ __exportStar(require("./assert/assert"), exports);
 var pyth_1 = require("./pyth");
 Object.defineProperty(exports, "PythLazerSubscriber", { enumerable: true, get: function () { return pyth_1.PythLazerSubscriber; } });
 __exportStar(require("./testClient"), exports);
+__exportStar(require("./equityFloorManager"), exports);
 __exportStar(require("./user"), exports);
 __exportStar(require("./userConfig"), exports);
 __exportStar(require("./userStats"), exports);
@@ -140,6 +141,7 @@ __exportStar(require("./tx/priorityFeeCalculator"), exports);
 __exportStar(require("./tx/types"), exports);
 __exportStar(require("./tx/txHandler"), exports);
 __exportStar(require("./tx/txParamProcessor"), exports);
+__exportStar(require("./tx/utils"), exports);
 __exportStar(require("./util/computeUnits"), exports);
 __exportStar(require("./util/digest"), exports);
 __exportStar(require("./util/promiseTimeout"), exports);

package/lib/browser/jupiter/jupiterClient.js

@@ -47,6 +47,7 @@ class JupiterClient {
      */
     async getQuote({ inputMint, outputMint, amount, maxAccounts = 50, // 50 is an estimated amount with buffer
     slippageBps = 50, swapMode = 'ExactIn', onlyDirectRoutes = false, excludeDexes, autoSlippage = false, maxAutoSlippageBps, usdEstimate, }) {
+        var _a;
         if (autoSlippage && maxAutoSlippageBps === undefined) {
             throw new Error('JupiterClient.getQuote: maxAutoSlippageBps is required when autoSlippage is enabled');
         }
@@ -78,7 +79,21 @@ class JupiterClient {
             : '';
         const headers = this.getHeaders();
         const fetchOptions = Object.keys(headers).length > 0 ? { headers } : {};
-        const quote = await (await (0, node_fetch_1.default)(`${this.url}${apiVersionParam}/quote?${params.toString()}`, fetchOptions)).json();
+        const response = await (0, node_fetch_1.default)(`${this.url}${apiVersionParam}/quote?${params.toString()}`, fetchOptions);
+        const quote = (await response.json().catch(() => undefined));
+        // A failed quote still returns parseable JSON — an `{ error, errorCode }`
+        // body with no mints or amounts. Returning it unchecked pushes the failure
+        // downstream to /swap, which rejects it with an opaque deserialization
+        // error ("missing field `inputMint`") that hides the real cause.
+        if (!response.ok || !quote) {
+            throw new Error(`Jupiter quote failed: ${response.status} ${(quote === null || quote === void 0 ? void 0 : quote.error) || (quote === null || quote === void 0 ? void 0 : quote.errorCode) || response.statusText}`);
+        }
+        if (quote.error || quote.errorCode) {
+            throw new Error(`Jupiter quote failed: ${(_a = quote.error) !== null && _a !== void 0 ? _a : quote.errorCode}`);
+        }
+        if (!quote.inputMint || !quote.outputMint || !quote.outAmount) {
+            throw new Error('Jupiter quote failed: response is missing route fields');
+        }
         return quote;
     }
     /**
@@ -134,12 +149,18 @@ class JupiterClient {
         };
     }
     async getLookupTable(accountKey) {
-        var _a;
         const cached = this.lookupTableCahce.get(accountKey.toString());
         if (cached !== undefined) {
             return cached;
         }
-        return ((_a = (await this.connection.getAddressLookupTable(accountKey)).value) !== null && _a !== void 0 ? _a : undefined);
+        const lookupTable = (await this.connection.getAddressLookupTable(accountKey)).value;
+        if (!lookupTable) {
+            return undefined;
+        }
+        // Populate the cache — without this every route re-fetches the same tables,
+        // which is a large share of the RPC calls a swap makes.
+        this.lookupTableCahce.set(accountKey.toString(), lookupTable);
+        return lookupTable;
     }
     /**
      * Get the jupiter instructions from transaction by filtering out instructions to compute budget and associated token programs

package/lib/browser/math/margin.d.ts

@@ -100,3 +100,29 @@ export declare function calculateMarginUSDCRequiredForTrade(velocityClient: Velo
  * @returns Collateral amount required, in `collateralIndex`'s own spot-market precision (via `velocityClient.convertToSpotPrecision`).
  */
 export declare function calculateCollateralDepositRequiredForTrade(velocityClient: VelocityClient, targetMarketIndex: number, baseSize: BN, collateralIndex: number, userMaxMarginRatio?: number, estEntryPrice?: BN): BN;
+/**
+ * Minimal equity floor to carry along with a quote transfer of `amount` out
+ * of a subaccount so the debited side ends at/above its buffered floor
+ * (`equityFloor + equityFloorBuffer`): the first
+ * `totalCollateral - (floor + buffer)` of the transfer carries no floor, the
+ * remainder carries floor one-for-one, capped at the floor the subaccount
+ * actually holds. Returns zero when no floor is set. The result never exceeds
+ * `amount`, so a credited side that met its own buffered floor before the
+ * transfer still meets it after. All values QUOTE_PRECISION.
+ */
+export declare function calculateEquityFloorAutoDelta(amount: BN, totalCollateral: BN, equityFloor: BN, equityFloorBuffer: BN): BN;
+/**
+ * Severity of a subaccount's equity relative to its floor, most to least
+ * severe. `breached`: below the floor, the permissionless breaker can trip.
+ * `critical`: below `floor + buffer`, risk-increasing actions are rejecting.
+ * `warning`: within `warningBufferMultiple * buffer` of the floor.
+ * `healthy`: above all thresholds. `disabled`: no floor set.
+ */
+export type EquityFloorLevel = 'breached' | 'critical' | 'warning' | 'healthy' | 'disabled';
+/**
+ * Classifies `totalCollateral` against the floor thresholds. Used by the
+ * `EquityFloorManager` and the equity-floor guard bot so both report the same
+ * levels. `warningBufferMultiple` scales the warning threshold above the
+ * floor (default 2: warn inside `floor + 2 * buffer`). All QUOTE_PRECISION.
+ */
+export declare function getEquityFloorLevel(totalCollateral: BN, equityFloor: BN, equityFloorBuffer: BN, warningBufferMultiple?: number): EquityFloorLevel;

package/lib/browser/math/margin.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.calculateCollateralDepositRequiredForTrade = exports.calculateMarginUSDCRequiredForTrade = exports.calculatePerpLiabilityValue = exports.calculateWorstCasePerpLiabilityValue = exports.calculateWorstCaseBaseAssetAmount = exports.calculateBaseAssetValueWithOracle = exports.calculateSizeDiscountAssetWeight = exports.calculateSizePremiumLiabilityWeight = void 0;
+exports.getEquityFloorLevel = exports.calculateEquityFloorAutoDelta = exports.calculateCollateralDepositRequiredForTrade = exports.calculateMarginUSDCRequiredForTrade = exports.calculatePerpLiabilityValue = exports.calculateWorstCasePerpLiabilityValue = exports.calculateWorstCaseBaseAssetAmount = exports.calculateBaseAssetValueWithOracle = exports.calculateSizeDiscountAssetWeight = exports.calculateSizePremiumLiabilityWeight = void 0;
 /**
  * Margin calculation helpers — TypeScript mirror of `programs/velocity/src/math/margin.rs`.
  * Computes initial/maintenance margin requirements, free collateral, and account health.
@@ -210,3 +210,43 @@ function calculateCollateralDepositRequiredForTrade(velocityClient, targetMarket
     return baseAmountRequired;
 }
 exports.calculateCollateralDepositRequiredForTrade = calculateCollateralDepositRequiredForTrade;
+/**
+ * Minimal equity floor to carry along with a quote transfer of `amount` out
+ * of a subaccount so the debited side ends at/above its buffered floor
+ * (`equityFloor + equityFloorBuffer`): the first
+ * `totalCollateral - (floor + buffer)` of the transfer carries no floor, the
+ * remainder carries floor one-for-one, capped at the floor the subaccount
+ * actually holds. Returns zero when no floor is set. The result never exceeds
+ * `amount`, so a credited side that met its own buffered floor before the
+ * transfer still meets it after. All values QUOTE_PRECISION.
+ */
+function calculateEquityFloorAutoDelta(amount, totalCollateral, equityFloor, equityFloorBuffer) {
+    if (equityFloor.lte(numericConstants_1.ZERO)) {
+        return numericConstants_1.ZERO;
+    }
+    const excess = anchor_1.BN.max(totalCollateral.sub(equityFloor.add(equityFloorBuffer)), numericConstants_1.ZERO);
+    return anchor_1.BN.min(anchor_1.BN.max(amount.sub(excess), numericConstants_1.ZERO), equityFloor);
+}
+exports.calculateEquityFloorAutoDelta = calculateEquityFloorAutoDelta;
+/**
+ * Classifies `totalCollateral` against the floor thresholds. Used by the
+ * `EquityFloorManager` and the equity-floor guard bot so both report the same
+ * levels. `warningBufferMultiple` scales the warning threshold above the
+ * floor (default 2: warn inside `floor + 2 * buffer`). All QUOTE_PRECISION.
+ */
+function getEquityFloorLevel(totalCollateral, equityFloor, equityFloorBuffer, warningBufferMultiple = 2) {
+    if (equityFloor.lte(numericConstants_1.ZERO)) {
+        return 'disabled';
+    }
+    if (totalCollateral.lt(equityFloor)) {
+        return 'breached';
+    }
+    if (totalCollateral.lt(equityFloor.add(equityFloorBuffer))) {
+        return 'critical';
+    }
+    if (totalCollateral.lt(equityFloor.add(equityFloorBuffer.muln(warningBufferMultiple)))) {
+        return 'warning';
+    }
+    return 'healthy';
+}
+exports.getEquityFloorLevel = getEquityFloorLevel;

package/lib/browser/swap/UnifiedSwapClient.js

@@ -3,6 +3,14 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.UnifiedSwapClient = void 0;
 const jupiterClient_1 = require("../jupiter/jupiterClient");
 const titanClient_1 = require("../titan/titanClient");
+const utils_1 = require("../tx/utils");
+/**
+ * Bytes reserved for the velocity begin/end swap instructions that wrap the
+ * route, so the provider only gets the budget actually left for the route.
+ */
+const VELOCITY_SWAP_IX_SIZE_BUFFER = 375;
+/** Byte budget handed to a swap provider for the route portion of the tx. */
+const DEFAULT_ROUTE_SIZE_CONSTRAINT = utils_1.MAX_TX_BYTE_SIZE - VELOCITY_SWAP_IX_SIZE_BUFFER;
 class UnifiedSwapClient {
     /**
      * Create a unified swap client
@@ -56,7 +64,7 @@ class UnifiedSwapClient {
                 ...titanParams,
                 userPublicKey: titanParams.userPublicKey,
                 swapMode: titanParams.swapMode, // Titan expects string
-                sizeConstraint: titanParams.sizeConstraint || 1280 - 375, // Use same default as getSwapInstructions
+                sizeConstraint: titanParams.sizeConstraint || DEFAULT_ROUTE_SIZE_CONSTRAINT,
             };
             return await titanClient.getQuote(titanParamsWithUser);
         }
@@ -131,7 +139,13 @@ class UnifiedSwapClient {
         }
         else {
             const titanClient = this.client;
-            // For Titan, get swap directly (it handles quote internally)
+            // For Titan, get swap directly (it handles quote internally).
+            //
+            // NOTE: `getSwap` reads only `userPublicKey` — it replays the route
+            // cached by the preceding `getQuote`, so every other argument here is
+            // inert. The size constraint is therefore enforced at quote time (see
+            // `getQuote` above), which means an explicit `sizeConstraint` passed
+            // only to this method does not affect route selection.
             const { transactionMessage, lookupTables: titanLookupTables } = await titanClient.getSwap({
                 inputMint,
                 outputMint,
@@ -140,7 +154,7 @@ class UnifiedSwapClient {
                 slippageBps,
                 swapMode: isExactOut ? titanClient_1.SwapMode.ExactOut : titanClient_1.SwapMode.ExactIn,
                 onlyDirectRoutes,
-                sizeConstraint: sizeConstraint || 1280 - 375, // MAX_TX_BYTE_SIZE - buffer for velocity instructions
+                sizeConstraint: sizeConstraint || DEFAULT_ROUTE_SIZE_CONSTRAINT,
             });
             swapInstructions = titanClient.getTitanInstructions({
                 transactionMessage,

package/lib/browser/titan/titanClient.d.ts

@@ -85,5 +85,11 @@ export declare class TitanClient {
         inputMint: PublicKey;
         outputMint: PublicKey;
     }): TransactionInstruction[];
+    /**
+     * Fetches a lookup table required by a route, retrying transient RPC
+     * failures (rate limiting in particular) before giving up.
+     * @throws If the table still can't be loaded, or doesn't exist on-chain.
+     */
+    private fetchLookupTable;
     private getTransactionMessageAndLookupTables;
 }

package/lib/browser/titan/titanClient.js

@@ -9,6 +9,10 @@ var SwapMode;
     SwapMode["ExactOut"] = "ExactOut";
 })(SwapMode || (exports.SwapMode = SwapMode = {}));
 const TITAN_API_URL = 'https://api.titan.exchange';
+/** Retries for a route's lookup tables, which must all resolve for the tx to fit. */
+const LOOKUP_TABLE_FETCH_RETRIES = 2;
+const LOOKUP_TABLE_RETRY_BASE_DELAY_MS = 150;
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 class TitanClient {
     constructor({ connection, authToken, url, proxyUrl, }) {
         this.connection = connection;
@@ -141,13 +145,13 @@ class TitanClient {
             throw new Error('No routes available');
         }
         if (route.instructions && route.instructions.length > 0) {
+            // Errors propagate as-is. Replacing them with generic copy here loses
+            // the reason the swap can't be built — an unresolvable lookup table,
+            // say — which the caller needs to decide whether re-quoting will help.
             try {
                 const { transactionMessage, lookupTables } = await this.getTransactionMessageAndLookupTables(route, userPublicKey);
                 return { transactionMessage, lookupTables };
             }
-            catch (err) {
-                throw new Error('Something went wrong with creating the Titan swap transaction. Please try again.');
-            }
             finally {
                 // Clear cached quote data after use
                 this.lastQuoteData = undefined;
@@ -189,6 +193,35 @@ class TitanClient {
         });
         return filteredInstructions;
     }
+    /**
+     * Fetches a lookup table required by a route, retrying transient RPC
+     * failures (rate limiting in particular) before giving up.
+     * @throws If the table still can't be loaded, or doesn't exist on-chain.
+     */
+    async fetchLookupTable(altPubkey) {
+        let lastError;
+        for (let attempt = 0; attempt <= LOOKUP_TABLE_FETCH_RETRIES; attempt++) {
+            if (attempt > 0) {
+                await sleep(LOOKUP_TABLE_RETRY_BASE_DELAY_MS * 2 ** (attempt - 1));
+            }
+            let altAccount;
+            try {
+                altAccount = await this.connection.getAddressLookupTable(altPubkey);
+            }
+            catch (err) {
+                // Transient — rate limiting, connection reset. Worth another go.
+                lastError = err;
+                continue;
+            }
+            if (altAccount.value) {
+                return altAccount.value;
+            }
+            // A successful response with no value means the route references a
+            // table that isn't on-chain. Retrying won't conjure it up.
+            throw new Error(`Address lookup table ${altPubkey.toString()} does not exist`);
+        }
+        throw new Error(`Failed to fetch address lookup table ${altPubkey.toString()}: ${lastError instanceof Error ? lastError.message : String(lastError)}`);
+    }
     async getTransactionMessageAndLookupTables(route, userPublicKey) {
         const solanaInstructions = route.instructions.map((instruction) => ({
             programId: new web3_js_1.PublicKey(instruction.p),
@@ -201,19 +234,17 @@ class TitanClient {
         }));
         // Get recent blockhash
         const { blockhash } = await this.connection.getLatestBlockhash();
-        // Build address lookup tables if provided
+        // Build address lookup tables if provided.
+        //
+        // These all have to resolve. A table that fails to load isn't a slightly
+        // worse route — every account it would have compressed to a 1-byte index
+        // gets inlined as a 32-byte pubkey instead, which pushes the transaction
+        // past the size limit and only surfaces later as an opaque
+        // "encoding overruns Uint8Array". Failing here lets the caller re-quote.
         const addressLookupTables = [];
         if (route.addressLookupTables && route.addressLookupTables.length > 0) {
             for (const altPubkey of route.addressLookupTables) {
-                try {
-                    const altAccount = await this.connection.getAddressLookupTable(new web3_js_1.PublicKey(altPubkey));
-                    if (altAccount.value) {
-                        addressLookupTables.push(altAccount.value);
-                    }
-                }
-                catch (err) {
-                    console.warn(`Failed to fetch address lookup table:`, err);
-                }
+                addressLookupTables.push(await this.fetchLookupTable(new web3_js_1.PublicKey(altPubkey)));
             }
         }
         const transactionMessage = new web3_js_1.TransactionMessage({

package/lib/browser/types.d.ts

@@ -116,7 +116,9 @@ export declare enum UserStatus {
     BEING_LIQUIDATED = 1,
     BANKRUPT = 2,
     REDUCE_ONLY = 4,
-    ADVANCED_LP = 8
+    ADVANCED_LP = 8,
+    /** Owned by a Strategy Vault (authority is a vault PDA; equity prices vault shares). Revenue-share sweeps skip such Users so a builder/referral reward can't enter vault NAV. */
+    VAULT_OWNED = 32
 }
 /** Bitmask mirror of `UserAccount.specialUserStatus`. `VAMM_HEDGER` marks the account used by the protocol's own vAMM-hedging bot. */
 export declare enum SpecialUserStatus {
@@ -1697,8 +1699,10 @@ export type UserAccount = {
     poolId: number;
     /** bitmask, see `SpecialUserStatus` */
     specialUserStatus: number;
-    /** QUOTE_PRECISION (1e6); admin-set minimum cross-margin total collateral for risk-increasing orders, fills, withdrawals and transfers; 0 = disabled */
+    /** QUOTE_PRECISION (1e6); admin-set minimum cross-margin total collateral; below it the permissionless breaker can trip; 0 = disabled */
     equityFloor: BN;
+    /** QUOTE_PRECISION (1e6); extra headroom above `equityFloor` required by risk-increasing orders, fills, withdrawals and transfers; no effect while `equityFloor` is 0 */
+    equityFloorBuffer: BN;
 };
 /** A user's balance in one spot market. Decoded mirror of the on-chain `SpotPosition`. */
 export type SpotPosition = {

package/lib/browser/types.js

@@ -103,6 +103,8 @@ var UserStatus;
     UserStatus[UserStatus["REDUCE_ONLY"] = 4] = "REDUCE_ONLY";
     UserStatus[UserStatus["ADVANCED_LP"] = 8] = "ADVANCED_LP";
     // 16 reserved (was PROTECTED_MAKER)
+    /** Owned by a Strategy Vault (authority is a vault PDA; equity prices vault shares). Revenue-share sweeps skip such Users so a builder/referral reward can't enter vault NAV. */
+    UserStatus[UserStatus["VAULT_OWNED"] = 32] = "VAULT_OWNED";
 })(UserStatus || (exports.UserStatus = UserStatus = {}));
 /** Bitmask mirror of `UserAccount.specialUserStatus`. `VAMM_HEDGER` marks the account used by the protocol's own vAMM-hedging bot. */
 var SpecialUserStatus;

package/lib/browser/user.d.ts

@@ -362,24 +362,23 @@ export declare class User {
      * @param marginCategory `'Initial'` or `'Maintenance'` asset/liability weights; omit for unweighted (100%) values.
      * @param liquidationBuffer Optional buffer (MARGIN_PRECISION, 1e4) added to the liability weight side.
      * @param includeOpenOrders If false, ignores open bids/asks and only counts the current balance (faster, less conservative).
-     * @param strict Use the worse of live oracle price vs 5-minute TWAP. Defaults to false.
-     * @param now Unix timestamp (seconds) used for TWAP staleness when `strict` is set; defaults to current time.
+     * @param strict Use the worse of live oracle price vs the market's stored 5-minute TWAP. Defaults to false.
      * @returns `{ totalAssetValue, totalLiabilityValue }`, both QUOTE_PRECISION (1e6) and non-negative.
      */
-    getSpotMarketAssetAndLiabilityValue(marketIndex?: number, marginCategory?: MarginCategory, liquidationBuffer?: BN, includeOpenOrders?: boolean, strict?: boolean, now?: BN): {
+    getSpotMarketAssetAndLiabilityValue(marketIndex?: number, marginCategory?: MarginCategory, liquidationBuffer?: BN, includeOpenOrders?: boolean, strict?: boolean): {
         totalAssetValue: BN;
         totalLiabilityValue: BN;
     };
     /** Convenience wrapper around `getSpotMarketAssetAndLiabilityValue` returning only `totalLiabilityValue`. See that method for parameter semantics. Returns QUOTE_PRECISION (1e6). */
-    getSpotMarketLiabilityValue(marketIndex?: number, marginCategory?: MarginCategory, liquidationBuffer?: BN, includeOpenOrders?: boolean, strict?: boolean, now?: BN): BN;
+    getSpotMarketLiabilityValue(marketIndex?: number, marginCategory?: MarginCategory, liquidationBuffer?: BN, includeOpenOrders?: boolean, strict?: boolean): BN;
     /** Thin wrapper around the `math/spotBalance` `getSpotLiabilityValue` helper that supplies the user's `maxMarginRatio`. Returns QUOTE_PRECISION (1e6), negative. */
     getSpotLiabilityValue(tokenAmount: BN, strictOraclePrice: StrictOraclePrice, spotMarketAccount: SpotMarketAccount, marginCategory?: MarginCategory, liquidationBuffer?: BN): BN;
     /** Convenience wrapper around `getSpotMarketAssetAndLiabilityValue` returning only `totalAssetValue`. See that method for parameter semantics. Returns QUOTE_PRECISION (1e6), non-negative. */
-    getSpotMarketAssetValue(marketIndex?: number, marginCategory?: MarginCategory, includeOpenOrders?: boolean, strict?: boolean, now?: BN): BN;
+    getSpotMarketAssetValue(marketIndex?: number, marginCategory?: MarginCategory, includeOpenOrders?: boolean, strict?: boolean): BN;
     /** Thin wrapper around the `math/spotBalance` `getSpotAssetValue` helper that supplies the user's `maxMarginRatio`. Returns QUOTE_PRECISION (1e6), non-negative. */
     getSpotAssetValue(tokenAmount: BN, strictOraclePrice: StrictOraclePrice, spotMarketAccount: SpotMarketAccount, marginCategory?: MarginCategory): BN;
     /** Net spot value (`totalAssetValue - totalLiabilityValue`) for a single spot market. See `getSpotMarketAssetAndLiabilityValue` for parameter semantics. Returns QUOTE_PRECISION (1e6), can be negative. */
-    getSpotPositionValue(marketIndex: number, marginCategory?: MarginCategory, includeOpenOrders?: boolean, strict?: boolean, now?: BN): BN;
+    getSpotPositionValue(marketIndex: number, marginCategory?: MarginCategory, includeOpenOrders?: boolean, strict?: boolean): BN;
     /**
      * Net spot value (`totalAssetValue - totalLiabilityValue`) across all spot
      * markets combined.
@@ -412,19 +411,46 @@ export declare class User {
     getTotalCollateral(marginCategory?: MarginCategory, strict?: boolean, includeOpenOrders?: boolean, liquidationBuffer?: BN, perpMarketIndex?: number): BN;
     /**
      * True when the account has an admin-set `equityFloor` and its cross-margin
-     * total collateral is below it. While below the floor, the program rejects
-     * risk-increasing order placement and fills, withdrawals, and transfers out
-     * of the account (`EquityBelowFloor`); reduce-only activity stays allowed.
+     * total collateral is below it. This is the trip threshold of the
+     * permissionless `tripEquityFloorBreaker`; action gating happens at
+     * `equityFloor + equityFloorBuffer` (see `isBelowBufferedEquityFloor`).
      * Mirrors `User::is_below_equity_floor` on-chain.
      * @param strict Use TWAP-bounded oracle pricing, matching the withdraw path. Defaults to false.
      */
     isBelowEquityFloor(strict?: boolean): boolean;
+    /**
+     * The equity required by risk-increasing actions:
+     * `equityFloor + equityFloorBuffer` (QUOTE_PRECISION). Mirrors
+     * `User::buffered_equity_floor` on-chain. Meaningless while
+     * `equityFloor` is 0 (the checks are disabled).
+     */
+    getBufferedEquityFloor(): BN;
+    /**
+     * True when the account has an admin-set `equityFloor` and its cross-margin
+     * total collateral is below `equityFloor + equityFloorBuffer`. While below,
+     * the program rejects risk-increasing order placement and fills,
+     * withdrawals, and transfers out of the account (`EquityBelowFloor`);
+     * reduce-only activity stays allowed. Mirrors
+     * `User::is_below_buffered_equity_floor` on-chain.
+     * @param strict Use TWAP-bounded oracle pricing, matching the withdraw path. Defaults to false.
+     */
+    isBelowBufferedEquityFloor(strict?: boolean): boolean;
     /**
      * Cross-margin total collateral in excess of the admin-set `equityFloor`,
      * floored at zero (QUOTE_PRECISION). Unbounded (`null`) when no floor is set.
+     * This is headroom above the trip threshold; headroom above the level
+     * risk-increasing actions must clear is `getEquityAboveBufferedFloor`.
      * @param strict Use TWAP-bounded oracle pricing. Defaults to false.
      */
     getEquityAboveFloor(strict?: boolean): BN | null;
+    /**
+     * Cross-margin total collateral in excess of `equityFloor +
+     * equityFloorBuffer`, floored at zero (QUOTE_PRECISION). Unbounded
+     * (`null`) when no floor is set. When this reaches zero, risk-increasing
+     * actions start rejecting.
+     * @param strict Use TWAP-bounded oracle pricing. Defaults to false.
+     */
+    getEquityAboveBufferedFloor(strict?: boolean): BN | null;
     /**
      * Builds the liquidation-buffer map to pass into margin calculations while
      * a liquidation is in progress: `'cross'` is set to the state account's
@@ -768,7 +794,7 @@ export declare class User {
      * @param outMarketIndex
      * @param calculateSwap Optional function to simulate the in-to-out conversion (e.g. to model swap fees/slippage); defaults to a 1:1 oracle-price conversion.
      * @param iterationLimit How many binary-search iterations to run before erroring out. Defaults to 1000.
-     * @returns `inAmount`/`outAmount` in each market's own token decimals, and the resulting `leverage` (TEN_THOUSAND, 1e4 precision) after the swap.
+     * @returns `inAmount`/`outAmount` in each market's own token decimals, and the resulting `leverage` (TEN_THOUSAND, 1e4 precision) after the swap. Sizing is TWAP-bounded to match the program's margin check; `leverage` is marked at the live oracle price so it stays comparable to `getLeverage()`.
      */
     getMaxSwapAmount({ inMarketIndex, outMarketIndex, calculateSwap, iterationLimit, }: {
         inMarketIndex: number;
@@ -796,7 +822,8 @@ export declare class User {
         totalLiabilityValue: BN;
     };
     /**
-     * Estimates what the user leverage will be after swap
+     * Estimates what the user leverage will be after swap, marked at the live
+     * oracle price so it stays comparable to `getLeverage()`.
      * @param inMarketIndex Market being sold/paid from.
      * @param outMarketIndex Market being bought/received.
      * @param inAmount Amount removed from `inMarketIndex`, that market's own token decimals.