@velocity-exchange/sdk 0.8.0 → 0.10.0

package/lib/browser/velocityClient.js

@@ -19,6 +19,7 @@ exports.VelocityClient = void 0;
  * Instruction → on-chain handler mapping: see ARCHITECTURE.md § SDK↔Instruction Mapping.
  */
 const anchor_1 = require("./isomorphic/anchor");
+const margin_1 = require("./math/margin");
 const bs58_1 = __importDefault(require("bs58"));
 const spl_token_1 = require("@solana/spl-token");
 const types_1 = require("./types");
@@ -44,7 +45,7 @@ const spotPosition_1 = require("./math/spotPosition");
 const market_1 = require("./math/market");
 const fetch_1 = require("./accounts/fetch");
 const spotMarket_1 = require("./math/spotMarket");
-const jupiterClient_1 = require("./jupiter/jupiterClient");
+const UnifiedSwapClient_1 = require("./swap/UnifiedSwapClient");
 const memcmp_1 = require("./memcmp");
 const marinade_1 = require("./marinade");
 const orderParams_1 = require("./orderParams");
@@ -60,8 +61,6 @@ const oracleId_1 = require("./oracles/oracleId");
 const utils_3 = require("./oracles/utils");
 const orders_1 = require("./math/orders");
 const builder_1 = require("./math/builder");
-const titanClient_1 = require("./titan/titanClient");
-const UnifiedSwapClient_1 = require("./swap/UnifiedSwapClient");
 /**
  * # VelocityClient
  * Main entry point for interacting with Velocity Exchange from TypeScript. A single instance wraps
@@ -3154,16 +3153,20 @@ 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
@@ -3200,14 +3203,8 @@ class VelocityClient {
                 throw new Error("equityFloorDelta 'auto' is only supported for the quote spot market; pass an explicit delta");
             }
             const fromUserClass = this.getUser(fromSubAccountId, this.authority);
-            const floor = fromUserClass.getUserAccountOrThrow().equityFloor;
-            if (floor.lte(numericConstants_1.ZERO)) {
-                resolvedFloorDelta = numericConstants_1.ZERO;
-            }
-            else {
-                const excess = anchor_1.BN.max(fromUserClass.getTotalCollateral('Initial', true).sub(floor), numericConstants_1.ZERO);
-                resolvedFloorDelta = anchor_1.BN.min(anchor_1.BN.max(amount.sub(excess), numericConstants_1.ZERO), floor);
-            }
+            const fromUserAccount = fromUserClass.getUserAccountOrThrow();
+            resolvedFloorDelta = (0, margin_1.calculateEquityFloorAutoDelta)(amount, fromUserClass.getNetUsdValue(), fromUserAccount.equityFloor, fromUserAccount.equityFloorBuffer);
         }
         else {
             resolvedFloorDelta = equityFloorDelta;
@@ -4721,234 +4718,182 @@ 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.
      */
-    async swap({ swapClient, jupiterClient, outMarketIndex, inMarketIndex, outAssociatedTokenAccount, inAssociatedTokenAccount, amount, slippageBps, swapMode, reduceOnly, txParams, v6, quote, onlyDirectRoutes = false, }) {
-        // Handle backward compatibility: use jupiterClient if swapClient is not provided
-        const clientToUse = swapClient || jupiterClient;
-        if (!clientToUse) {
+    async swap({ swapClient, outMarketIndex, inMarketIndex, outAssociatedTokenAccount, inAssociatedTokenAccount, amount, slippageBps, swapMode, reduceOnly, txParams, quote, onlyDirectRoutes = false, }) {
+        if (!swapClient) {
             throw new Error('Either swapClient or jupiterClient must be provided');
         }
-        let res;
-        // Use unified SwapClient if available
-        if (clientToUse instanceof UnifiedSwapClient_1.UnifiedSwapClient) {
-            res = await this.getSwapIxV2({
-                swapClient: clientToUse,
-                outMarketIndex,
-                inMarketIndex,
-                outAssociatedTokenAccount,
-                inAssociatedTokenAccount,
-                amount,
-                slippageBps,
-                swapMode,
-                onlyDirectRoutes,
-                reduceOnly,
-                quote,
-                v6,
-            });
-        }
-        else if (clientToUse instanceof titanClient_1.TitanClient) {
-            res = await this.getTitanSwapIx({
-                titanClient: clientToUse,
-                outMarketIndex,
-                inMarketIndex,
-                outAssociatedTokenAccount,
-                inAssociatedTokenAccount,
-                amount,
-                slippageBps,
-                swapMode,
-                onlyDirectRoutes,
-                reduceOnly,
-            });
-        }
-        else if (clientToUse instanceof jupiterClient_1.JupiterClient) {
-            const quoteToUse = quote !== null && quote !== void 0 ? quote : v6 === null || v6 === void 0 ? void 0 : v6.quote;
-            res = await this.getJupiterSwapIxV6({
-                jupiterClient: clientToUse,
-                outMarketIndex,
-                inMarketIndex,
-                outAssociatedTokenAccount,
-                inAssociatedTokenAccount,
-                amount,
-                slippageBps,
-                swapMode,
-                quote: quoteToUse,
-                reduceOnly,
-                onlyDirectRoutes,
-            });
-        }
-        else {
-            throw new Error('Invalid swap client type. Must be SwapClient, TitanClient, or JupiterClient.');
-        }
-        const ixs = res.ixs;
-        const lookupTables = res.lookupTables;
+        const { ixs, lookupTables } = await this.getProviderSwapIx({
+            swapProvider: swapClient,
+            outMarketIndex,
+            inMarketIndex,
+            outAssociatedTokenAccount,
+            inAssociatedTokenAccount,
+            amount,
+            slippageBps,
+            swapMode,
+            onlyDirectRoutes,
+            reduceOnly,
+            quote,
+        });
         const tx = (await this.buildTransaction(ixs, txParams, 0, lookupTables));
         const { txSig, slot } = await this.sendTransaction(tx);
         this.cacheSpotMarketSlot(slot, outMarketIndex, inMarketIndex);
         return txSig;
     }
     /**
-     * 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.
      */
-    async getTitanSwapIx({ titanClient, outMarketIndex, inMarketIndex, outAssociatedTokenAccount, inAssociatedTokenAccount, amount, slippageBps, swapMode, onlyDirectRoutes, reduceOnly, userAccountPublicKey, }) {
-        const outMarket = this.getSpotMarketAccountOrThrow(outMarketIndex);
-        const inMarket = this.getSpotMarketAccountOrThrow(inMarketIndex);
+    assertQuoteMatchesMarkets(quote, inMarket, outMarket) {
+        if (!new web3_js_1.PublicKey(quote.inputMint).equals(inMarket.mint)) {
+            throw new Error(`Quote sells ${quote.inputMint} but spot market ${inMarket.marketIndex} is ${inMarket.mint.toString()}.`);
+        }
+        if (!new web3_js_1.PublicKey(quote.outputMint).equals(outMarket.mint)) {
+            throw new Error(`Quote buys ${quote.outputMint} but spot market ${outMarket.marketIndex} is ${outMarket.mint.toString()}.`);
+        }
+    }
+    /**
+     * 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.
+     */
+    assertQuoteMatchesAmount(quote, amount, swapMode) {
         const isExactOut = swapMode === 'ExactOut';
-        const exactOutBufferedAmountIn = amount.muln(1001).divn(1000); // Add 10bp buffer
-        const preInstructions = [];
-        if (!outAssociatedTokenAccount) {
-            const tokenProgram = this.getTokenProgramForSpotMarket(outMarket);
-            outAssociatedTokenAccount = await this.getAssociatedTokenAccount(outMarket.marketIndex, false, tokenProgram);
-            const accountInfo = await this.connection.getAccountInfo(outAssociatedTokenAccount);
-            if (!accountInfo) {
-                preInstructions.push(this.createAssociatedTokenAccountIdempotentInstruction(outAssociatedTokenAccount, this.provider.wallet.publicKey, this.provider.wallet.publicKey, outMarket.mint, tokenProgram));
-            }
+        const quoted = isExactOut ? quote.outAmount : quote.inAmount;
+        if (quoted !== amount.toString()) {
+            throw new Error(`Quote is for ${quoted} ${isExactOut ? 'out' : 'in'} but the swap asked for ${amount.toString()} (${swapMode}).`);
         }
-        if (!inAssociatedTokenAccount) {
-            const tokenProgram = this.getTokenProgramForSpotMarket(inMarket);
-            inAssociatedTokenAccount = await this.getAssociatedTokenAccount(inMarket.marketIndex, false, tokenProgram);
-            const accountInfo = await this.connection.getAccountInfo(inAssociatedTokenAccount);
-            if (!accountInfo) {
-                preInstructions.push(this.createAssociatedTokenAccountIdempotentInstruction(inAssociatedTokenAccount, this.provider.wallet.publicKey, this.provider.wallet.publicKey, inMarket.mint, tokenProgram));
-            }
+    }
+    /**
+     * Resolves the wallet's associated token account for a spot market, plus the instruction that
+     * creates it when it doesn't exist yet.
+     */
+    async getOrCreateSwapTokenAccount(market) {
+        const tokenProgram = this.getTokenProgramForSpotMarket(market);
+        const tokenAccount = await this.getAssociatedTokenAccount(market.marketIndex, false, tokenProgram);
+        if (await this.connection.getAccountInfo(tokenAccount)) {
+            return { tokenAccount };
         }
-        const { beginSwapIx, endSwapIx } = await this.getSwapIx({
-            outMarketIndex,
-            inMarketIndex,
-            amountIn: isExactOut ? exactOutBufferedAmountIn : amount,
-            inTokenAccount: inAssociatedTokenAccount,
-            outTokenAccount: outAssociatedTokenAccount,
-            reduceOnly,
-            userAccountPublicKey,
-        });
-        const { transactionMessage, lookupTables } = await titanClient.getSwap({
-            inputMint: inMarket.mint,
-            outputMint: outMarket.mint,
-            amount,
-            userPublicKey: this.provider.wallet.publicKey,
-            slippageBps,
-            swapMode: isExactOut ? titanClient_1.SwapMode.ExactOut : titanClient_1.SwapMode.ExactIn,
-            onlyDirectRoutes,
-            sizeConstraint: utils_2.MAX_TX_BYTE_SIZE - 375, // buffer for velocity instructions
-        });
-        const titanInstructions = titanClient.getTitanInstructions({
-            transactionMessage,
-            inputMint: inMarket.mint,
-            outputMint: outMarket.mint,
-        });
-        const ixs = [
-            ...preInstructions,
-            beginSwapIx,
-            ...titanInstructions,
-            endSwapIx,
-        ];
-        return { ixs, lookupTables };
+        return {
+            tokenAccount,
+            createIx: this.createAssociatedTokenAccountIdempotentInstruction(tokenAccount, this.provider.wallet.publicKey, this.provider.wallet.publicKey, market.mint, tokenProgram),
+        };
     }
     /**
-     * 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.
+     * 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.
      */
-    async getJupiterSwapIxV6({ jupiterClient, outMarketIndex, inMarketIndex, outAssociatedTokenAccount, inAssociatedTokenAccount, amount, slippageBps, swapMode, onlyDirectRoutes, quote, reduceOnly, userAccountPublicKey, }) {
+    async getProviderSwapIx({ swapProvider, outMarketIndex, inMarketIndex, outAssociatedTokenAccount, inAssociatedTokenAccount, amount, slippageBps, swapMode, onlyDirectRoutes, maxAccounts, reduceOnly, quote, userAccountPublicKey, }) {
+        var _a, _b;
         const outMarket = this.getSpotMarketAccountOrThrow(outMarketIndex);
         const inMarket = this.getSpotMarketAccountOrThrow(inMarketIndex);
-        if (!quote) {
-            const fetchedQuote = await jupiterClient.getQuote({
-                inputMint: inMarket.mint,
-                outputMint: outMarket.mint,
-                amount,
-                slippageBps,
-                swapMode,
-                onlyDirectRoutes,
-            });
-            quote = fetchedQuote;
-        }
-        if (!quote) {
-            throw new Error('Could not fetch swap quote. Please try again.');
-        }
-        const isExactOut = swapMode === 'ExactOut' || quote.swapMode === 'ExactOut';
-        const amountIn = new anchor_1.BN(quote.inAmount);
-        const exactOutBufferedAmountIn = amountIn.muln(1001).divn(1000); // Add 10bp buffer
-        const transaction = await jupiterClient.getSwap({
-            quote,
-            userPublicKey: this.provider.wallet.publicKey,
-            slippageBps,
-        });
-        const { transactionMessage, lookupTables } = await jupiterClient.getTransactionMessageAndLookupTables({
-            transaction,
-        });
-        const jupiterInstructions = jupiterClient.getJupiterInstructions({
-            transactionMessage,
+        const quoteToUse = quote !== null && quote !== void 0 ? quote : (await swapProvider.getQuote({
             inputMint: inMarket.mint,
             outputMint: outMarket.mint,
-        });
+            amount,
+            userPublicKey: this.provider.wallet.publicKey,
+            slippageBps,
+            swapMode: swapMode !== null && swapMode !== void 0 ? swapMode : 'ExactIn',
+            onlyDirectRoutes,
+            maxAccounts,
+            sizeConstraint: UnifiedSwapClient_1.DEFAULT_ROUTE_SIZE_CONSTRAINT,
+        }));
+        // The quote's own mode decides which side `amount` names and how `beginSwap` is sized, so it
+        // wins over `swapMode` whether the quote was passed in or just fetched — a provider that
+        // answers in the other mode is then caught by the size check rather than sizing the wrong side.
+        const effectiveSwapMode = (_b = (_a = quoteToUse.swapMode) !== null && _a !== void 0 ? _a : swapMode) !== null && _b !== void 0 ? _b : 'ExactIn';
+        // Both paths, identically: a freshly fetched quote is no more trustworthy about what it
+        // priced than one handed to us.
+        this.assertQuoteMatchesMarkets(quoteToUse, inMarket, outMarket);
+        this.assertQuoteMatchesAmount(quoteToUse, amount, effectiveSwapMode);
+        // Size `beginSwap` off the quote's own input: under ExactOut `amount` is the requested
+        // output, so buffering it would be a guess at what the route consumes.
+        const quotedAmountIn = new anchor_1.BN(quoteToUse.inAmount);
+        const amountIn = effectiveSwapMode === 'ExactOut'
+            ? quotedAmountIn.muln(1001).divn(1000) // Add 10bp buffer
+            : quotedAmountIn;
         const preInstructions = [];
         if (!outAssociatedTokenAccount) {
-            const tokenProgram = this.getTokenProgramForSpotMarket(outMarket);
-            outAssociatedTokenAccount = await this.getAssociatedTokenAccount(outMarket.marketIndex, false, tokenProgram);
-            const accountInfo = await this.connection.getAccountInfo(outAssociatedTokenAccount);
-            if (!accountInfo) {
-                preInstructions.push(this.createAssociatedTokenAccountIdempotentInstruction(outAssociatedTokenAccount, this.provider.wallet.publicKey, this.provider.wallet.publicKey, outMarket.mint, tokenProgram));
+            const { tokenAccount, createIx } = await this.getOrCreateSwapTokenAccount(outMarket);
+            outAssociatedTokenAccount = tokenAccount;
+            if (createIx) {
+                preInstructions.push(createIx);
             }
         }
         if (!inAssociatedTokenAccount) {
-            const tokenProgram = this.getTokenProgramForSpotMarket(inMarket);
-            inAssociatedTokenAccount = await this.getAssociatedTokenAccount(inMarket.marketIndex, false, tokenProgram);
-            const accountInfo = await this.connection.getAccountInfo(inAssociatedTokenAccount);
-            if (!accountInfo) {
-                preInstructions.push(this.createAssociatedTokenAccountIdempotentInstruction(inAssociatedTokenAccount, this.provider.wallet.publicKey, this.provider.wallet.publicKey, inMarket.mint, tokenProgram));
+            const { tokenAccount, createIx } = await this.getOrCreateSwapTokenAccount(inMarket);
+            inAssociatedTokenAccount = tokenAccount;
+            if (createIx) {
+                preInstructions.push(createIx);
             }
         }
         const { beginSwapIx, endSwapIx } = await this.getSwapIx({
             outMarketIndex,
             inMarketIndex,
-            amountIn: isExactOut ? exactOutBufferedAmountIn : amountIn,
+            amountIn,
             inTokenAccount: inAssociatedTokenAccount,
             outTokenAccount: outAssociatedTokenAccount,
             reduceOnly,
             userAccountPublicKey,
         });
-        const ixs = [
-            ...preInstructions,
-            beginSwapIx,
-            ...jupiterInstructions,
-            endSwapIx,
-        ];
-        return { ixs, lookupTables };
+        const { instructions: routeInstructions, lookupTables } = await swapProvider.getRouteInstructions({
+            quote: quoteToUse,
+            userPublicKey: this.provider.wallet.publicKey,
+        });
+        return {
+            ixs: [...preInstructions, beginSwapIx, ...routeInstructions, endSwapIx],
+            lookupTables,
+        };
     }
     /**
      * Builds the `beginSwap`/`endSwap` instruction pair that must bracket an external swap
@@ -5053,88 +4998,6 @@ class VelocityClient {
         });
         return { beginSwapIx, endSwapIx };
     }
-    /**
-     * 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.
-     */
-    async getSwapIxV2({ swapClient, outMarketIndex, inMarketIndex, outAssociatedTokenAccount, inAssociatedTokenAccount, amount, slippageBps, swapMode, onlyDirectRoutes, reduceOnly, quote, v6, userAccountPublicKey, }) {
-        // Get market accounts to determine mints
-        const outMarket = this.getSpotMarketAccountOrThrow(outMarketIndex);
-        const inMarket = this.getSpotMarketAccountOrThrow(inMarketIndex);
-        const isExactOut = swapMode === 'ExactOut';
-        const preInstructions = [];
-        // Handle token accounts if not provided
-        let finalOutAssociatedTokenAccount = outAssociatedTokenAccount;
-        let finalInAssociatedTokenAccount = inAssociatedTokenAccount;
-        if (!finalOutAssociatedTokenAccount) {
-            const tokenProgram = this.getTokenProgramForSpotMarket(outMarket);
-            finalOutAssociatedTokenAccount = await this.getAssociatedTokenAccount(outMarket.marketIndex, false, tokenProgram);
-            const accountInfo = await this.connection.getAccountInfo(finalOutAssociatedTokenAccount);
-            if (!accountInfo) {
-                preInstructions.push(this.createAssociatedTokenAccountIdempotentInstruction(finalOutAssociatedTokenAccount, this.provider.wallet.publicKey, this.provider.wallet.publicKey, outMarket.mint, tokenProgram));
-            }
-        }
-        if (!finalInAssociatedTokenAccount) {
-            const tokenProgram = this.getTokenProgramForSpotMarket(inMarket);
-            finalInAssociatedTokenAccount = await this.getAssociatedTokenAccount(inMarket.marketIndex, false, tokenProgram);
-            const accountInfo = await this.connection.getAccountInfo(finalInAssociatedTokenAccount);
-            if (!accountInfo) {
-                preInstructions.push(this.createAssociatedTokenAccountIdempotentInstruction(finalInAssociatedTokenAccount, this.provider.wallet.publicKey, this.provider.wallet.publicKey, inMarket.mint, tokenProgram));
-            }
-        }
-        let amountInForBeginSwap;
-        if (isExactOut) {
-            if (quote || (v6 === null || v6 === void 0 ? void 0 : v6.quote)) {
-                amountInForBeginSwap = (v6 === null || v6 === void 0 ? void 0 : v6.quote)
-                    ? new anchor_1.BN(v6.quote.inAmount)
-                    : new anchor_1.BN(quote.inAmount);
-            }
-            else {
-                amountInForBeginSwap = amount.muln(1001).divn(1000);
-            }
-        }
-        else {
-            amountInForBeginSwap = amount;
-        }
-        // Get velocity swap instructions for begin and end
-        const { beginSwapIx, endSwapIx } = await this.getSwapIx({
-            outMarketIndex,
-            inMarketIndex,
-            amountIn: amountInForBeginSwap,
-            inTokenAccount: finalInAssociatedTokenAccount,
-            outTokenAccount: finalOutAssociatedTokenAccount,
-            reduceOnly,
-            userAccountPublicKey,
-        });
-        // Get core swap instructions from SwapClient
-        const swapResult = await swapClient.getSwapInstructions({
-            inputMint: inMarket.mint,
-            outputMint: outMarket.mint,
-            amount,
-            userPublicKey: this.provider.wallet.publicKey,
-            slippageBps,
-            swapMode,
-            onlyDirectRoutes,
-            quote: quote !== null && quote !== void 0 ? quote : v6 === null || v6 === void 0 ? void 0 : v6.quote,
-        });
-        const allInstructions = [
-            ...preInstructions,
-            beginSwapIx,
-            ...swapResult.instructions,
-            endSwapIx,
-        ];
-        return {
-            ixs: allInstructions,
-            lookupTables: swapResult.lookupTables,
-        };
-    }
     /**
      * 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
@@ -5278,11 +5141,12 @@ class VelocityClient {
     }
     /**
      * 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.
@@ -6802,11 +6666,13 @@ 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.
      */
     async getJupiterLiquidateSpotWithSwapIxV6({ jupiterClient, liabilityMarketIndex, assetMarketIndex, swapAmount, assetTokenAccount, liabilityTokenAccount, slippageBps, swapMode, onlyDirectRoutes, quote, userAccount, userAccountPublicKey, liquidatorSubAccountId, maxAccounts, }) {
+        var _a, _b;
         const liabilityMarket = this.getSpotMarketAccountOrThrow(liabilityMarketIndex);
         const assetMarket = this.getSpotMarketAccountOrThrow(assetMarketIndex);
         if (!quote) {
@@ -6824,19 +6690,12 @@ class VelocityClient {
         if (!quote) {
             throw new Error('Could not fetch swap quote. Please try again.');
         }
+        this.assertQuoteMatchesMarkets(quote, assetMarket, liabilityMarket);
+        this.assertQuoteMatchesAmount(quote, swapAmount, (_b = (_a = quote.swapMode) !== null && _a !== void 0 ? _a : swapMode) !== null && _b !== void 0 ? _b : 'ExactIn');
         const amountIn = new anchor_1.BN(quote.inAmount);
-        const transaction = await jupiterClient.getSwap({
+        const { instructions: jupiterInstructions, lookupTables } = await jupiterClient.getRouteInstructions({
             quote,
             userPublicKey: this.provider.wallet.publicKey,
-            slippageBps,
-        });
-        const { transactionMessage, lookupTables } = await jupiterClient.getTransactionMessageAndLookupTables({
-            transaction,
-        });
-        const jupiterInstructions = jupiterClient.getJupiterInstructions({
-            transactionMessage,
-            inputMint: assetMarket.mint,
-            outputMint: liabilityMarket.mint,
         });
         const preInstructions = [];
         if (!liabilityTokenAccount) {

package/lib/node/adminClient.d.ts

@@ -17,7 +17,7 @@ import { AddressLookupTableAccount, Keypair, PublicKey, TransactionInstruction,
 import { FeeStructure, OracleGuardRails, OracleSource, ExchangeStatus, SolvencyStatus, MarketStatus, ContractTier, AssetTier, TxParams, AddAmmConstituentMappingDatum, SwapReduceOnly, InitializeConstituentParams, ConstituentStatus, LPPoolAccount, TransferFeeAndPnlPoolDirection, MarketType } from './types';
 import { BN } from './isomorphic/anchor';
 import { VelocityClient } from './velocityClient';
-import { JupiterClient, QuoteResponse } from './jupiter/jupiterClient';
+import { JupiterClient, JupiterSwapQuote } from './jupiter/jupiterClient';
 import { SwapMode } from './swap/UnifiedSwapClient';
 export declare class AdminClient extends VelocityClient {
     /**
@@ -2283,7 +2283,7 @@ export declare class AdminClient extends VelocityClient {
         slippageBps?: number;
         swapMode?: SwapMode;
         onlyDirectRoutes?: boolean;
-        quote?: QuoteResponse;
+        quote?: JupiterSwapQuote;
         lpPoolId: number;
     }): Promise<{
         ixs: TransactionInstruction[];
@@ -2500,24 +2500,27 @@ export declare class AdminClient extends VelocityClient {
      */
     getUpdateSpecialUserStatusIx(userAccountPublicKey: PublicKey, status: number): Promise<TransactionInstruction>;
     /**
-     * Sets a `User` account's `equityFloor`: the minimum cross-margin total
-     * collateral (QUOTE_PRECISION) the account must keep. Below the floor the
-     * program rejects risk-increasing order placement and fills, withdrawals,
-     * and deposit/position transfers out of the account; reduce-only activity
-     * stays allowed. Requires warm admin (`check_warm`); the account's
-     * authority and delegate cannot change it. Pass `0` to disable.
+     * Sets a `User` account's `equityFloor` and `equityFloorBuffer`. The floor
+     * is the minimum cross-margin total collateral (QUOTE_PRECISION) below
+     * which the permissionless breaker can trip; risk-increasing order
+     * placement and fills, withdrawals, and deposit/position transfers out of
+     * the account must clear `floor + buffer` (`EquityBelowFloor` otherwise);
+     * reduce-only activity stays allowed. Requires warm admin (`check_warm`);
+     * the account's authority and delegate cannot change either value. Pass
+     * `0` as the floor to disable both checks.
      * @param userAccountPublicKey - `User` PDA to update.
      * @param equityFloor - New floor, QUOTE_PRECISION; `0` disables.
+     * @param equityFloorBuffer - New buffer, QUOTE_PRECISION; no effect while the floor is 0.
      * @param txParams - Optional transaction-building overrides.
      * @returns Transaction signature.
      */
-    updateUserEquityFloor(userAccountPublicKey: PublicKey, equityFloor: BN, txParams?: TxParams): Promise<TransactionSignature>;
+    updateUserEquityFloor(userAccountPublicKey: PublicKey, equityFloor: BN, equityFloorBuffer: BN, txParams?: TxParams): Promise<TransactionSignature>;
     /**
      * Builds the `updateUserEquityFloor` instruction without sending it. See
      * `updateUserEquityFloor`.
      * @returns The unsigned `updateUserEquityFloor` instruction.
      */
-    getUpdateUserEquityFloorIx(userAccountPublicKey: PublicKey, equityFloor: BN): Promise<TransactionInstruction>;
+    getUpdateUserEquityFloorIx(userAccountPublicKey: PublicKey, equityFloor: BN, equityFloorBuffer: BN): Promise<TransactionInstruction>;
     /**
      * Clears the authority-wide equity floor breaker set by the permissionless
      * `tripEquityFloorBreaker` keeper instruction, unfreezing all of the