@velocity-exchange/sdk 0.8.0 → 0.10.0

package/lib/browser/user.js

@@ -724,12 +724,10 @@ 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, marginCategory, liquidationBuffer, includeOpenOrders, strict = false, now) {
-        now = now || new anchor_1.BN(new Date().getTime() / 1000);
+    getSpotMarketAssetAndLiabilityValue(marketIndex, marginCategory, liquidationBuffer, includeOpenOrders, strict = false) {
         let netQuoteValue = numericConstants_1.ZERO;
         let totalAssetValue = numericConstants_1.ZERO;
         let totalLiabilityValue = numericConstants_1.ZERO;
@@ -744,11 +742,11 @@ class User {
             }
             const spotMarketAccount = this.velocityClient.getSpotMarketAccountOrThrow(spotPosition.marketIndex);
             const oraclePriceData = this.getOracleDataForSpotMarket(spotPosition.marketIndex);
-            let twap5min;
-            if (strict) {
-                twap5min = (0, oracles_1.calculateLiveOracleTwap)(spotMarketAccount.historicalOracleData, oraclePriceData, now, numericConstants_1.FIVE_MINUTE // 5MIN
-                );
-            }
+            // mirrors margin.rs: strict mode prices against the market's *stored*
+            // 5min TWAP, not a live-projected one
+            const twap5min = strict
+                ? spotMarketAccount.historicalOracleData.lastOraclePriceTwap5Min
+                : undefined;
             const strictOraclePrice = new strictOraclePrice_1.StrictOraclePrice(oraclePriceData.price, twap5min);
             if (spotPosition.marketIndex === numericConstants_1.QUOTE_SPOT_MARKET_INDEX &&
                 countForQuote) {
@@ -813,8 +811,8 @@ class User {
         return { totalAssetValue, totalLiabilityValue };
     }
     /** Convenience wrapper around `getSpotMarketAssetAndLiabilityValue` returning only `totalLiabilityValue`. See that method for parameter semantics. Returns QUOTE_PRECISION (1e6). */
-    getSpotMarketLiabilityValue(marketIndex, marginCategory, liquidationBuffer, includeOpenOrders, strict = false, now) {
-        const { totalLiabilityValue } = this.getSpotMarketAssetAndLiabilityValue(marketIndex, marginCategory, liquidationBuffer, includeOpenOrders, strict, now);
+    getSpotMarketLiabilityValue(marketIndex, marginCategory, liquidationBuffer, includeOpenOrders, strict = false) {
+        const { totalLiabilityValue } = this.getSpotMarketAssetAndLiabilityValue(marketIndex, marginCategory, liquidationBuffer, includeOpenOrders, strict);
         return totalLiabilityValue;
     }
     /** Thin wrapper around the `math/spotBalance` `getSpotLiabilityValue` helper that supplies the user's `maxMarginRatio`. Returns QUOTE_PRECISION (1e6), negative. */
@@ -822,8 +820,8 @@ class User {
         return (0, spotBalance_2.getSpotLiabilityValue)(tokenAmount, strictOraclePrice, spotMarketAccount, this.getUserAccountOrThrow().maxMarginRatio, marginCategory, liquidationBuffer);
     }
     /** Convenience wrapper around `getSpotMarketAssetAndLiabilityValue` returning only `totalAssetValue`. See that method for parameter semantics. Returns QUOTE_PRECISION (1e6), non-negative. */
-    getSpotMarketAssetValue(marketIndex, marginCategory, includeOpenOrders, strict = false, now) {
-        const { totalAssetValue } = this.getSpotMarketAssetAndLiabilityValue(marketIndex, marginCategory, undefined, includeOpenOrders, strict, now);
+    getSpotMarketAssetValue(marketIndex, marginCategory, includeOpenOrders, strict = false) {
+        const { totalAssetValue } = this.getSpotMarketAssetAndLiabilityValue(marketIndex, marginCategory, undefined, includeOpenOrders, strict);
         return totalAssetValue;
     }
     /** Thin wrapper around the `math/spotBalance` `getSpotAssetValue` helper that supplies the user's `maxMarginRatio`. Returns QUOTE_PRECISION (1e6), non-negative. */
@@ -831,8 +829,8 @@ class User {
         return (0, spotBalance_2.getSpotAssetValue)(tokenAmount, strictOraclePrice, spotMarketAccount, this.getUserAccountOrThrow().maxMarginRatio, marginCategory);
     }
     /** Net spot value (`totalAssetValue - totalLiabilityValue`) for a single spot market. See `getSpotMarketAssetAndLiabilityValue` for parameter semantics. Returns QUOTE_PRECISION (1e6), can be negative. */
-    getSpotPositionValue(marketIndex, marginCategory, includeOpenOrders, strict = false, now) {
-        const { totalAssetValue, totalLiabilityValue } = this.getSpotMarketAssetAndLiabilityValue(marketIndex, marginCategory, undefined, includeOpenOrders, strict, now);
+    getSpotPositionValue(marketIndex, marginCategory, includeOpenOrders, strict = false) {
+        const { totalAssetValue, totalLiabilityValue } = this.getSpotMarketAssetAndLiabilityValue(marketIndex, marginCategory, undefined, includeOpenOrders, strict);
         return totalAssetValue.sub(totalLiabilityValue);
     }
     /**
@@ -899,31 +897,71 @@ class User {
         return marginCalc.totalCollateral;
     }
     /**
-     * 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.
-     * Mirrors `User::is_below_equity_floor` on-chain.
-     * @param strict Use TWAP-bounded oracle pricing, matching the withdraw path. Defaults to false.
+     * True when the account has an admin-set `equityFloor` and its net equity
+     * (`getNetUsdValue`: unweighted assets and perp PnL minus unweighted spot
+     * liabilities, at live oracle prices) 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`
+     * onchain.
+     */
+    isBelowEquityFloor() {
+        const equityFloor = this.getUserAccountOrThrow().equityFloor;
+        if (equityFloor.lte(numericConstants_1.ZERO)) {
+            return false;
+        }
+        return this.getNetUsdValue().lt(equityFloor);
+    }
+    /**
+     * 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() {
+        const userAccount = this.getUserAccountOrThrow();
+        return userAccount.equityFloor.add(userAccount.equityFloorBuffer);
+    }
+    /**
+     * True when the account has an admin-set `equityFloor` and its net equity
+     * (`getNetUsdValue`) 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.
      */
-    isBelowEquityFloor(strict = false) {
+    isBelowBufferedEquityFloor() {
         const equityFloor = this.getUserAccountOrThrow().equityFloor;
         if (equityFloor.lte(numericConstants_1.ZERO)) {
             return false;
         }
-        return this.getTotalCollateral('Initial', strict).lt(equityFloor);
+        return this.getNetUsdValue().lt(this.getBufferedEquityFloor());
     }
     /**
-     * Cross-margin total collateral in excess of the admin-set `equityFloor`,
+     * Net equity (`getNetUsdValue`) in excess of the admin-set `equityFloor`,
      * floored at zero (QUOTE_PRECISION). Unbounded (`null`) when no floor is set.
-     * @param strict Use TWAP-bounded oracle pricing. Defaults to false.
+     * This is headroom above the trip threshold; headroom above the level
+     * risk-increasing actions must clear is `getEquityAboveBufferedFloor`.
+     */
+    getEquityAboveFloor() {
+        const equityFloor = this.getUserAccountOrThrow().equityFloor;
+        if (equityFloor.lte(numericConstants_1.ZERO)) {
+            return null;
+        }
+        return anchor_1.BN.max(this.getNetUsdValue().sub(equityFloor), numericConstants_1.ZERO);
+    }
+    /**
+     * Net equity (`getNetUsdValue`) 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.
      */
-    getEquityAboveFloor(strict = false) {
+    getEquityAboveBufferedFloor() {
         const equityFloor = this.getUserAccountOrThrow().equityFloor;
         if (equityFloor.lte(numericConstants_1.ZERO)) {
             return null;
         }
-        return anchor_1.BN.max(this.getTotalCollateral('Initial', strict).sub(equityFloor), numericConstants_1.ZERO);
+        return anchor_1.BN.max(this.getNetUsdValue().sub(this.getBufferedEquityFloor()), numericConstants_1.ZERO);
     }
     /**
      * Builds the liquidation-buffer map to pass into margin calculations while
@@ -1979,7 +2017,7 @@ 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 = 1000, }) {
         const inMarket = this.velocityClient.getSpotMarketAccountOrThrow(inMarketIndex);
@@ -1988,8 +2026,14 @@ class User {
         const inOraclePrice = inOraclePriceData.price;
         const outOraclePriceData = this.getOracleDataForSpotMarket(outMarketIndex);
         const outOraclePrice = outOraclePriceData.price;
-        const inStrictOraclePrice = new strictOraclePrice_1.StrictOraclePrice(inOraclePrice);
-        const outStrictOraclePrice = new strictOraclePrice_1.StrictOraclePrice(outOraclePrice);
+        // sizing mirrors handle_end_swap: both legs are priced strictly, against
+        // each market's stored 5min TWAP
+        const inStrictOraclePrice = new strictOraclePrice_1.StrictOraclePrice(inOraclePrice, inMarket.historicalOracleData.lastOraclePriceTwap5Min);
+        const outStrictOraclePrice = new strictOraclePrice_1.StrictOraclePrice(outOraclePrice, outMarket.historicalOracleData.lastOraclePriceTwap5Min);
+        // the returned leverage is a delta on top of getLeverageComponents' live-oracle
+        // baseline, so pricing its legs strictly would mix two bases in one figure
+        const inLeveragePrice = new strictOraclePrice_1.StrictOraclePrice(inOraclePrice);
+        const outLeveragePrice = new strictOraclePrice_1.StrictOraclePrice(outOraclePrice);
         const inPrecision = new anchor_1.BN(10 ** inMarket.decimals);
         const outPrecision = new anchor_1.BN(10 ** outMarket.decimals);
         const inSpotPosition = this.getSpotPosition(inMarketIndex) ||
@@ -1998,9 +2042,9 @@ class User {
             this.getEmptySpotPosition(outMarketIndex);
         const freeCollateral = this.getFreeCollateral();
         const inContributionInitial = this.calculateSpotPositionFreeCollateralContribution(inSpotPosition, inStrictOraclePrice);
-        const { totalAssetValue: inTotalAssetValueInitial, totalLiabilityValue: inTotalLiabilityValueInitial, } = this.calculateSpotPositionLeverageContribution(inSpotPosition, inStrictOraclePrice);
+        const { totalAssetValue: inTotalAssetValueInitial, totalLiabilityValue: inTotalLiabilityValueInitial, } = this.calculateSpotPositionLeverageContribution(inSpotPosition, inLeveragePrice);
         const outContributionInitial = this.calculateSpotPositionFreeCollateralContribution(outSpotPosition, outStrictOraclePrice);
-        const { totalAssetValue: outTotalAssetValueInitial, totalLiabilityValue: outTotalLiabilityValueInitial, } = this.calculateSpotPositionLeverageContribution(outSpotPosition, outStrictOraclePrice);
+        const { totalAssetValue: outTotalAssetValueInitial, totalLiabilityValue: outTotalLiabilityValueInitial, } = this.calculateSpotPositionLeverageContribution(outSpotPosition, outLeveragePrice);
         const initialContribution = inContributionInitial.add(outContributionInitial);
         const { perpLiabilityValue, perpPnl, spotAssetValue, spotLiabilityValue } = this.getLeverageComponents();
         if (!calculateSwap) {
@@ -2063,8 +2107,8 @@ class User {
         }
         const inPositionAfter = this.cloneAndUpdateSpotPosition(inSpotPosition, inSwap.neg(), inMarket);
         const outPositionAfter = this.cloneAndUpdateSpotPosition(outSpotPosition, outSwap, outMarket);
-        const { totalAssetValue: inTotalAssetValueAfter, totalLiabilityValue: inTotalLiabilityValueAfter, } = this.calculateSpotPositionLeverageContribution(inPositionAfter, inStrictOraclePrice);
-        const { totalAssetValue: outTotalAssetValueAfter, totalLiabilityValue: outTotalLiabilityValueAfter, } = this.calculateSpotPositionLeverageContribution(outPositionAfter, outStrictOraclePrice);
+        const { totalAssetValue: inTotalAssetValueAfter, totalLiabilityValue: inTotalLiabilityValueAfter, } = this.calculateSpotPositionLeverageContribution(inPositionAfter, inLeveragePrice);
+        const { totalAssetValue: outTotalAssetValueAfter, totalLiabilityValue: outTotalLiabilityValueAfter, } = this.calculateSpotPositionLeverageContribution(outPositionAfter, outLeveragePrice);
         const spotAssetValueDelta = inTotalAssetValueAfter
             .add(outTotalAssetValueAfter)
             .sub(inTotalAssetValueInitial)
@@ -2147,7 +2191,8 @@ class User {
         };
     }
     /**
-     * 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.
@@ -2161,19 +2206,21 @@ class User {
         const inOraclePrice = inOraclePriceData.price;
         const outOraclePriceData = this.getOracleDataForSpotMarket(outMarketIndex);
         const outOraclePrice = outOraclePriceData.price;
-        const inStrictOraclePrice = new strictOraclePrice_1.StrictOraclePrice(inOraclePrice);
-        const outStrictOraclePrice = new strictOraclePrice_1.StrictOraclePrice(outOraclePrice);
+        // same live-oracle basis as getMaxSwapAmount's leverage legs and as the
+        // getLeverageComponents baseline these deltas are applied to
+        const inLeveragePrice = new strictOraclePrice_1.StrictOraclePrice(inOraclePrice);
+        const outLeveragePrice = new strictOraclePrice_1.StrictOraclePrice(outOraclePrice);
         const inSpotPosition = this.getSpotPosition(inMarketIndex) ||
             this.getEmptySpotPosition(inMarketIndex);
         const outSpotPosition = this.getSpotPosition(outMarketIndex) ||
             this.getEmptySpotPosition(outMarketIndex);
-        const { totalAssetValue: inTotalAssetValueInitial, totalLiabilityValue: inTotalLiabilityValueInitial, } = this.calculateSpotPositionLeverageContribution(inSpotPosition, inStrictOraclePrice);
-        const { totalAssetValue: outTotalAssetValueInitial, totalLiabilityValue: outTotalLiabilityValueInitial, } = this.calculateSpotPositionLeverageContribution(outSpotPosition, outStrictOraclePrice);
+        const { totalAssetValue: inTotalAssetValueInitial, totalLiabilityValue: inTotalLiabilityValueInitial, } = this.calculateSpotPositionLeverageContribution(inSpotPosition, inLeveragePrice);
+        const { totalAssetValue: outTotalAssetValueInitial, totalLiabilityValue: outTotalLiabilityValueInitial, } = this.calculateSpotPositionLeverageContribution(outSpotPosition, outLeveragePrice);
         const { perpLiabilityValue, perpPnl, spotAssetValue, spotLiabilityValue } = this.getLeverageComponents();
         const inPositionAfter = this.cloneAndUpdateSpotPosition(inSpotPosition, inAmount.abs().neg(), inMarket);
         const outPositionAfter = this.cloneAndUpdateSpotPosition(outSpotPosition, outAmount.abs(), outMarket);
-        const { totalAssetValue: inTotalAssetValueAfter, totalLiabilityValue: inTotalLiabilityValueAfter, } = this.calculateSpotPositionLeverageContribution(inPositionAfter, inStrictOraclePrice);
-        const { totalAssetValue: outTotalAssetValueAfter, totalLiabilityValue: outTotalLiabilityValueAfter, } = this.calculateSpotPositionLeverageContribution(outPositionAfter, outStrictOraclePrice);
+        const { totalAssetValue: inTotalAssetValueAfter, totalLiabilityValue: inTotalLiabilityValueAfter, } = this.calculateSpotPositionLeverageContribution(inPositionAfter, inLeveragePrice);
+        const { totalAssetValue: outTotalAssetValueAfter, totalLiabilityValue: outTotalLiabilityValueAfter, } = this.calculateSpotPositionLeverageContribution(outPositionAfter, outLeveragePrice);
         const spotAssetValueDelta = inTotalAssetValueAfter
             .add(outTotalAssetValueAfter)
             .sub(inTotalAssetValueInitial)
@@ -2380,9 +2427,9 @@ class User {
         const spotMarket = this.velocityClient.getSpotMarketAccountOrThrow(marketIndex);
         // eslint-disable-next-line prefer-const
         let { borrowLimit, withdrawLimit } = (0, spotBalance_2.calculateWithdrawLimit)(spotMarket, nowTs);
-        // the withdraw path enforces the equity floor on post-withdraw total
-        // collateral, so equity above the floor caps free collateral here
-        const equityAboveFloor = this.getEquityAboveFloor(true);
+        // the withdraw path enforces the equity floor on post-withdraw net
+        // equity, so equity above the floor caps free collateral here
+        const equityAboveFloor = this.getEquityAboveFloor();
         if (equityAboveFloor !== null && equityAboveFloor.eq(numericConstants_1.ZERO)) {
             return numericConstants_1.ZERO;
         }
@@ -2921,8 +2968,10 @@ class User {
                 skipTokenValue = true;
             }
             const oraclePriceData = this.getOracleDataForSpotMarket(spotPosition.marketIndex);
+            // mirrors margin.rs: strict mode prices against the market's *stored*
+            // 5min TWAP, not a live-projected one
             const twap5 = strict
-                ? (0, oracles_1.calculateLiveOracleTwap)(spotMarket.historicalOracleData, oraclePriceData, new anchor_1.BN(Math.floor(Date.now() / 1000)), numericConstants_1.FIVE_MINUTE)
+                ? spotMarket.historicalOracleData.lastOraclePriceTwap5Min
                 : undefined;
             const strictOracle = new strictOraclePrice_1.StrictOraclePrice(oraclePriceData.price, twap5);
             if (isQuote) {

package/lib/browser/velocityClient.d.ts

@@ -30,8 +30,8 @@ import { User } from './user';
 import { UserSubscriptionConfig } from './userConfig';
 import { VelocityEnv, VelocityProgram } from './config';
 import { UserStats } from './userStats';
-import { JupiterClient, QuoteResponse } from './jupiter/jupiterClient';
-import { SwapMode, UnifiedQuoteResponse } from './swap/UnifiedSwapClient';
+import { JupiterClient, JupiterSwapQuote } from './jupiter/jupiterClient';
+import { SwapMode, SwapProvider, SwapQuote } from './swap/types';
 import { UserStatsSubscriptionConfig } from './userStatsConfig';
 import { TxHandler } from './tx/txHandler';
 import { SignedMsgOrderParams } from './types';
@@ -39,7 +39,6 @@ import { TakerInfo } from './types';
 import { ConstituentMap } from './constituentMap/constituentMap';
 import { RevenueShareEscrowMap } from './userMap/revenueShareEscrowMap';
 import { TitanClient } from './titan/titanClient';
-import { UnifiedSwapClient } from './swap/UnifiedSwapClient';
 /**
  * Union type for swap clients (Titan and Jupiter) - Legacy type
  * @deprecated Use UnifiedSwapClient class instead
@@ -1573,16 +1572,20 @@ export declare class VelocityClient {
      * @param fromSubAccountId - Sub-account id to debit.
      * @param toSubAccountId - Sub-account id to credit.
      * @param equityFloorDelta - Equity floor (QUOTE_PRECISION) to move from the debited to the credited
-     * sub-account along with the funds, keeping the sum of floors constant. The debited side must not
+     * sub-account along with the funds, keeping the sum of floors constant. A proportional share of
+     * the debited side's `equityFloorBuffer` travels with the floor (rounded up on the debited side,
+     * so shedding the whole floor also sheds the whole buffer; no orphan buffer is left on a
+     * check-disabled sub-account), keeping the sum of buffers constant too. The debited side must not
      * already be below the floor being reduced (a below-floor sub-account cannot shed floor to defuse a
-     * pending equity-breaker trip), must stay at/above its reduced floor, and the credited side's
-     * collateral (after the transfer lands) must back its increased floor, else the transfer reverts with
-     * `InvalidEquityFloorTransfer`. Pass `'auto'`
+     * pending equity-breaker trip), must stay at/above its reduced floor plus its reduced buffer,
+     * and the credited side's net equity (after the transfer lands) must back its increased floor plus
+     * its increased buffer, else the transfer reverts with `InvalidEquityFloorTransfer`. Pass `'auto'`
      * (quote market only) to move the minimal floor needed for the debited side to stay at/above its
-     * floor: `max(0, amount - (collateral - floor))`, capped at the debited side's floor. The auto delta
-     * never exceeds `amount`, so the credited side stays backed whenever it was before. Client-side
-     * pricing can differ slightly from the on-chain strict check at the exact boundary; retry with an
-     * explicit padded delta if an `'auto'` transfer reverts. Defaults to zero.
+     * buffered floor: `max(0, amount - max(0, netEquity - (floor + buffer)))`, capped at the debited
+     * side's floor (see `calculateEquityFloorAutoDelta`). The auto delta never exceeds `amount`, so the
+     * credited side stays backed whenever it was before. Client-side pricing can differ slightly from
+     * the onchain check at the exact boundary; retry with an explicit padded delta if an
+     * `'auto'` transfer reverts. Defaults to zero.
      * @param txParams - Optional compute-unit/priority-fee overrides for the transaction.
      * @returns The transaction signature.
      * @throws (on-chain) if `allowDelegateTransfer` is not enabled, if the signer is not the delegate on
@@ -2304,34 +2307,32 @@ export declare class VelocityClient {
      * instructions in a single transaction, so the swap is settled directly against the user's
      * deposits/vault balances rather than the wallet's own token accounts. Sends and confirms the
      * transaction.
-     * @param swapClient - Swap client used to fetch routes/instructions (`UnifiedSwapClient` or a
-     * `TitanClient`); dispatches to `getSwapIxV2` or `getTitanSwapIx` respectively.
-     * @param jupiterClient - @deprecated Use `swapClient` instead. When passed (and `swapClient` is
-     * not), dispatches to `getJupiterSwapIxV6`.
+     * @param swapClient - Provider used to quote the swap and build its route: a
+     * `UnifiedSwapClient`, or a `TitanClient`/`JupiterClient` directly. See `getProviderSwapIx`.
+     * @param jupiterClient - @deprecated Use `swapClient` instead. Used only when `swapClient` is
+     * not passed.
      * @param outMarketIndex - Spot market index of the token being bought.
      * @param inMarketIndex - Spot market index of the token being sold.
      * @param outAssociatedTokenAccount - Token account to receive the bought token; created
      * idempotently if omitted.
      * @param inAssociatedTokenAccount - Token account to source the sold token from; created
      * idempotently if omitted.
-     * @param amount - Amount of the "in" token (or "out" token when `swapMode` is `ExactOut`, in
-     * which case this is the desired output amount), in the token's own mint decimals — not a
-     * fixed protocol precision.
+     * @param amount - Amount of the "in" token (or "out" token when the effective mode is
+     * `ExactOut`, in which case this is the desired output amount), in the token's own mint
+     * decimals — not a fixed protocol precision.
      * @param slippageBps - Max slippage in basis points passed to the swap provider's routing API.
-     * @param swapMode - `ExactIn` (default) or `ExactOut`.
+     * @param swapMode - `ExactIn` (default) or `ExactOut`. Ignored when `quote` is passed — the
+     * quote's own mode wins.
      * @param reduceOnly - Whether the in/out token's position on the velocity account must reduce
      * (not flip sign); enforced by `endSwap` after the swap completes.
-     * @param v6 - @deprecated Use `quote` instead. Pre-fetched Jupiter v6 quote response.
-     * @param quote - Pre-fetched quote response (skips an extra round-trip to the swap provider).
+     * @param quote - Pre-fetched quote (skips an extra round-trip to the swap provider). Must be
+     * for this pair and this `amount`.
      * @param txParams - Optional compute-unit/priority-fee overrides.
-     * @throws If neither `swapClient` nor `jupiterClient` is provided, or if `swapClient` is not a
-     * recognized client type.
+     * @throws If neither `swapClient` nor `jupiterClient` is provided.
      * @returns The transaction signature.
      */
-    swap({ swapClient, jupiterClient, outMarketIndex, inMarketIndex, outAssociatedTokenAccount, inAssociatedTokenAccount, amount, slippageBps, swapMode, reduceOnly, txParams, v6, quote, onlyDirectRoutes, }: {
-        swapClient?: UnifiedSwapClient | SwapClient;
-        /** @deprecated Use swapClient instead. Legacy parameter for backward compatibility */
-        jupiterClient?: JupiterClient;
+    swap({ swapClient, outMarketIndex, inMarketIndex, outAssociatedTokenAccount, inAssociatedTokenAccount, amount, slippageBps, swapMode, reduceOnly, txParams, quote, onlyDirectRoutes, }: {
+        swapClient?: SwapProvider;
         outMarketIndex: number;
         inMarketIndex: number;
         outAssociatedTokenAccount?: PublicKey;
@@ -2342,49 +2343,59 @@ export declare class VelocityClient {
         reduceOnly?: SwapReduceOnly;
         txParams?: TxParams;
         onlyDirectRoutes?: boolean;
-        v6?: {
-            quote?: QuoteResponse;
-        };
-        quote?: UnifiedQuoteResponse;
+        quote?: SwapQuote;
     }): Promise<TransactionSignature>;
     /**
-     * Builds the instruction list for a Titan-routed swap: creates any missing associated token
-     * accounts, wraps Titan's routing instructions between `beginSwap`/`endSwap`. See `swap` for
-     * parameter semantics; `amount` is in the "in" token's mint decimals.
-     * @param userAccountPublicKey - Optional user account override (e.g. when the account is being
-     * created in the same transaction and not yet resolvable via `getUserAccountPublicKey`).
-     * @returns `ixs` — instruction list (ATA creation, `beginSwap`, Titan swap instructions,
-     * `endSwap`, in order) and `lookupTables` needed to fit it in a versioned transaction.
+     * Throws unless a quote swaps exactly the pair the `beginSwap`/`endSwap` pair is being built
+     * for. A mismatched quote routes and executes normally, but deposits its output into a token
+     * account `endSwap` isn't watching, so it reverts with `InvalidSwap: amount_out must be
+     * greater than 0` only after the funds have already moved.
      */
-    getTitanSwapIx({ titanClient, outMarketIndex, inMarketIndex, outAssociatedTokenAccount, inAssociatedTokenAccount, amount, slippageBps, swapMode, onlyDirectRoutes, reduceOnly, userAccountPublicKey, }: {
-        titanClient: TitanClient;
-        outMarketIndex: number;
-        inMarketIndex: number;
-        outAssociatedTokenAccount?: PublicKey;
-        inAssociatedTokenAccount?: PublicKey;
-        amount: BN;
-        slippageBps?: number;
-        swapMode?: string;
-        onlyDirectRoutes?: boolean;
-        reduceOnly?: SwapReduceOnly;
-        userAccountPublicKey?: PublicKey;
-    }): Promise<{
-        ixs: TransactionInstruction[];
-        lookupTables: AddressLookupTableAccount[];
-    }>;
+    protected assertQuoteMatchesMarkets(quote: {
+        inputMint: string;
+        outputMint: string;
+    }, inMarket: SpotMarketAccount, outMarket: SpotMarketAccount): void;
     /**
-     * Builds the instruction list for a Jupiter v6-routed swap: fetches a quote if none is passed,
-     * creates any missing associated token accounts, and wraps Jupiter's routing instructions
-     * between `beginSwap`/`endSwap`. See `swap` for parameter semantics; `amount` is in the "in"
-     * token's mint decimals.
+     * Throws unless a quote is for the size the caller asked to swap. `beginSwap` releases funds
+     * sized off the quote, so a quote for a different size moves the wrong amount out of the user's
+     * deposits.
+     */
+    private assertQuoteMatchesAmount;
+    /**
+     * Resolves the wallet's associated token account for a spot market, plus the instruction that
+     * creates it when it doesn't exist yet.
+     */
+    private getOrCreateSwapTokenAccount;
+    /**
+     * Builds the instruction list for a swap routed through any `SwapProvider` (Jupiter, Titan, or
+     * a `UnifiedSwapClient` wrapping either): creates any missing associated token accounts and
+     * wraps the provider's routing instructions between `beginSwap`/`endSwap`.
+     * @param swapProvider - Provider that quotes the swap and builds its route instructions.
+     * @param outMarketIndex - Spot market index of the token being bought.
+     * @param inMarketIndex - Spot market index of the token being sold.
+     * @param outAssociatedTokenAccount - Token account to receive the bought token; created
+     * idempotently if omitted.
+     * @param inAssociatedTokenAccount - Token account to source the sold token from; created
+     * idempotently if omitted.
+     * @param amount - Amount in the "in" token's mint decimals, or the "out" token's when the
+     * effective mode is `ExactOut`.
+     * @param slippageBps - Max slippage in basis points; only used when a quote has to be fetched.
+     * @param swapMode - `ExactIn` (default) or `ExactOut`. The mode a quote is fetched at; the
+     * resulting quote's own mode is what sizes the swap, so it is ignored when `quote` is passed.
+     * @param onlyDirectRoutes - Restricts a fetched quote to single-hop routes.
+     * @param maxAccounts - Account budget for a fetched route.
+     * @param reduceOnly - Which side must not increase in magnitude; enforced by `endSwap`.
+     * @param quote - Pre-fetched quote. Authoritative when passed: its `swapMode` is the effective
+     * mode, and it must be for this pair and this `amount`.
      * @param userAccountPublicKey - Optional user account override (e.g. when the account is being
-     * created in the same transaction).
-     * @throws If no quote is passed and Jupiter's quote API returns none.
-     * @returns `ixs` — instruction list (ATA creation, `beginSwap`, Jupiter swap instructions,
-     * `endSwap`, in order) and `lookupTables` needed to fit it in a versioned transaction.
+     * created in the same transaction and not yet resolvable via `getUserAccountPublicKey`).
+     * @throws If the quote — passed in or freshly fetched — is for a different pair or a different
+     * size than the swap being built.
+     * @returns `ixs` — ATA creation, `beginSwap`, the route's instructions, `endSwap`, in order —
+     * and the `lookupTables` needed to fit them in a versioned transaction.
      */
-    getJupiterSwapIxV6({ jupiterClient, outMarketIndex, inMarketIndex, outAssociatedTokenAccount, inAssociatedTokenAccount, amount, slippageBps, swapMode, onlyDirectRoutes, quote, reduceOnly, userAccountPublicKey, }: {
-        jupiterClient: JupiterClient;
+    getProviderSwapIx({ swapProvider, outMarketIndex, inMarketIndex, outAssociatedTokenAccount, inAssociatedTokenAccount, amount, slippageBps, swapMode, onlyDirectRoutes, maxAccounts, reduceOnly, quote, userAccountPublicKey, }: {
+        swapProvider: SwapProvider;
         outMarketIndex: number;
         inMarketIndex: number;
         outAssociatedTokenAccount?: PublicKey;
@@ -2393,8 +2404,9 @@ export declare class VelocityClient {
         slippageBps?: number;
         swapMode?: SwapMode;
         onlyDirectRoutes?: boolean;
-        quote?: QuoteResponse;
+        maxAccounts?: number;
         reduceOnly?: SwapReduceOnly;
+        quote?: SwapQuote;
         userAccountPublicKey?: PublicKey;
     }): Promise<{
         ixs: TransactionInstruction[];
@@ -2434,37 +2446,6 @@ export declare class VelocityClient {
         beginSwapIx: TransactionInstruction;
         endSwapIx: TransactionInstruction;
     }>;
-    /**
-     * Builds the instruction list for a swap routed through a `UnifiedSwapClient` (the current
-     * preferred swap path). Creates any missing associated token accounts and wraps the client's
-     * routing instructions between `beginSwap`/`endSwap`. See `swap` for parameter semantics;
-     * `amount` is in the "in" token's mint decimals (or "out" token's decimals when `swapMode` is
-     * `ExactOut`).
-     * @param userAccountPublicKey - Optional user account override (e.g. when the account is being
-     * created in the same transaction).
-     * @returns `ixs` — instruction list (ATA creation, `beginSwap`, routed swap instructions,
-     * `endSwap`, in order) and `lookupTables` needed to fit it in a versioned transaction.
-     */
-    getSwapIxV2({ swapClient, outMarketIndex, inMarketIndex, outAssociatedTokenAccount, inAssociatedTokenAccount, amount, slippageBps, swapMode, onlyDirectRoutes, reduceOnly, quote, v6, userAccountPublicKey, }: {
-        swapClient: UnifiedSwapClient;
-        outMarketIndex: number;
-        inMarketIndex: number;
-        outAssociatedTokenAccount?: PublicKey;
-        inAssociatedTokenAccount?: PublicKey;
-        amount: BN;
-        slippageBps?: number;
-        swapMode?: SwapMode;
-        onlyDirectRoutes?: boolean;
-        reduceOnly?: SwapReduceOnly;
-        quote?: UnifiedQuoteResponse;
-        v6?: {
-            quote?: QuoteResponse;
-        };
-        userAccountPublicKey?: PublicKey;
-    }): Promise<{
-        ixs: TransactionInstruction[];
-        lookupTables: AddressLookupTableAccount[];
-    }>;
     /**
      * Converts a portion of the user's deposited wSOL (spot market index 1) into mSOL (spot market
      * index 2) by staking it with Marinade Finance, then swapping the resulting mSOL back into the
@@ -2533,11 +2514,12 @@ export declare class VelocityClient {
     getForceCancelOrdersIx(userAccountPublicKey: PublicKey, userAccount: UserAccount, fillerPublicKey?: PublicKey): Promise<TransactionInstruction>;
     /**
      * Keeper instruction: trips the authority-wide equity floor breaker. Proves on-chain that the
-     * given subaccount's cross-margin total collateral is below its `equityFloor` (reverts with
-     * `SufficientCollateral` otherwise, or if no floor is set) and sets `equityBreakerTripped` on the
-     * authority's `UserStats` — every subaccount of the authority then rejects risk-increasing fills,
-     * withdrawals and transfers out until the warm admin calls `resetEquityFloorBreaker`.
-     * Permissionless — any signer may trip it; the margin calculation is the proof.
+     * given subaccount's net equity (unweighted assets and perp PnL minus spot liabilities) is below
+     * its `equityFloor` (reverts with `SufficientCollateral` otherwise, if no floor is set, or with
+     * `InvalidOracle` if any of the subaccount's oracles is invalid) and sets `equityBreakerTripped`
+     * on the authority's `UserStats` — every subaccount of the authority then rejects risk-increasing
+     * fills, withdrawals and transfers out until the warm admin calls `resetEquityFloorBreaker`.
+     * Permissionless — any signer may trip it; the equity calculation is the proof.
      * @param userAccountPublicKey - Public key of the breached subaccount's user account.
      * @param user - Decoded user account of the breached subaccount.
      * @param txParams - Optional compute-unit/priority-fee overrides.
@@ -3325,7 +3307,8 @@ export declare class VelocityClient {
      * @param userAccountPublicKey - Public key of the user account being liquidated.
      * @param liquidatorSubAccountId - Liquidator's sub-account to credit; defaults to the active sub-account.
      * @param maxAccounts - Caps the number of accounts Jupiter's route may use.
-     * @throws If no quote can be fetched and `quote` was not supplied.
+     * @throws If no quote can be fetched and `quote` was not supplied, or if the quote — passed in or
+     * freshly fetched — is for a different pair or a different size than the swap being built.
      * @returns The ordered instructions (pre-instructions, `beginSwap`, Jupiter swap, `endSwap`) and
      * any address lookup tables the Jupiter route requires.
      */
@@ -3339,7 +3322,7 @@ export declare class VelocityClient {
         slippageBps?: number;
         swapMode?: SwapMode;
         onlyDirectRoutes?: boolean;
-        quote?: QuoteResponse;
+        quote?: JupiterSwapQuote;
         userAccount: UserAccount;
         userAccountPublicKey: PublicKey;
         liquidatorSubAccountId?: number;