@velocity-exchange/sdk 0.8.0 → 0.10.0

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,45 @@ 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
+ * `netEquity - (floor + buffer)` of the transfer carries no floor, the
+ * remainder carries floor one-for-one, capped at the floor the subaccount
+ * actually holds. `netEquity` is `User.getNetUsdValue()`, the metric the
+ * onchain floor checks use. 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, netEquity, equityFloor, equityFloorBuffer) {
+    if (equityFloor.lte(numericConstants_1.ZERO)) {
+        return numericConstants_1.ZERO;
+    }
+    const excess = anchor_1.BN.max(netEquity.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 `netEquity` (`User.getNetUsdValue()`) 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(netEquity, equityFloor, equityFloorBuffer, warningBufferMultiple = 2) {
+    if (equityFloor.lte(numericConstants_1.ZERO)) {
+        return 'disabled';
+    }
+    if (netEquity.lt(equityFloor)) {
+        return 'breached';
+    }
+    if (netEquity.lt(equityFloor.add(equityFloorBuffer))) {
+        return 'critical';
+    }
+    if (netEquity.lt(equityFloor.add(equityFloorBuffer.muln(warningBufferMultiple)))) {
+        return 'warning';
+    }
+    return 'healthy';
+}
+exports.getEquityFloorLevel = getEquityFloorLevel;

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

@@ -1,5 +1,5 @@
 import { AddressLookupTableAccount, PublicKey, TransactionInstruction } from '@solana/web3.js';
-import { JupiterClient, QuoteResponse } from '../jupiter/jupiterClient';
+import { JupiterClient, JupiterSwapQuote } from '../jupiter/jupiterClient';
 import { VelocityClient } from '../velocityClient';
 import { BN } from '../isomorphic/anchor';
 import { User } from '../user';
@@ -61,7 +61,7 @@ export declare function fetchBSolVelocityEmissions(): Promise<fetch.Response>;
  * @param {boolean} [params.forceMarinade] - Force the direct Marinade stake path over a Jupiter
  *   swap even if Jupiter would be cheaper (market index 2 only)
  * @param {boolean} [params.onlyDirectRoutes] - Restrict Jupiter routing to direct swaps only
- * @param {QuoteResponse} [params.jupiterQuote] - A pre-fetched Jupiter quote to reuse instead of
+ * @param {JupiterSwapQuote} [params.jupiterQuote] - A pre-fetched Jupiter quote to reuse instead of
  *   fetching a fresh one
  * @return {Promise<{ ixs: TransactionInstruction[]; lookupTables: AddressLookupTableAccount[];
  *   method: 'jupiter' | 'marinade'; price?: number }>} The instructions to submit, any address
@@ -78,7 +78,7 @@ export declare function findBestSuperStakeIxs({ marketIndex, amount, jupiterClie
     userAccountPublicKey?: PublicKey;
     forceMarinade?: boolean;
     onlyDirectRoutes?: boolean;
-    jupiterQuote?: QuoteResponse;
+    jupiterQuote?: JupiterSwapQuote;
 }): Promise<{
     ixs: TransactionInstruction[];
     lookupTables: AddressLookupTableAccount[];
@@ -100,7 +100,7 @@ export declare function findBestSuperStakeIxs({ marketIndex, amount, jupiterClie
  * @param {PublicKey} [params.userAccountPublicKey] - The target sub-account
  * @param {boolean} [params.forceMarinade] - Force the Marinade path regardless of Jupiter pricing
  * @param {boolean} [params.onlyDirectRoutes] - Restrict Jupiter routing to direct swaps only
- * @param {QuoteResponse} [params.jupiterQuote] - A pre-fetched Jupiter quote to reuse
+ * @param {JupiterSwapQuote} [params.jupiterQuote] - A pre-fetched Jupiter quote to reuse
  * @return {Promise<{ ixs: TransactionInstruction[]; lookupTables: AddressLookupTableAccount[];
  *   method: 'jupiter' | 'marinade'; price: number }>} The chosen route's instructions, required
  *   lookup tables, the method used, and the mSOL/SOL price used for the decision
@@ -113,7 +113,7 @@ export declare function findBestMSolSuperStakeIxs({ amount, jupiterClient, veloc
     userAccountPublicKey?: PublicKey;
     forceMarinade?: boolean;
     onlyDirectRoutes?: boolean;
-    jupiterQuote?: QuoteResponse;
+    jupiterQuote?: JupiterSwapQuote;
 }): Promise<{
     ixs: TransactionInstruction[];
     lookupTables: AddressLookupTableAccount[];
@@ -130,7 +130,7 @@ export declare function findBestMSolSuperStakeIxs({ amount, jupiterClient, veloc
  * @param {VelocityClient} params.velocityClient - Velocity client
  * @param {PublicKey} [params.userAccountPublicKey] - The target sub-account
  * @param {boolean} [params.onlyDirectRoutes] - Restrict Jupiter routing to direct swaps only
- * @param {QuoteResponse} [params.jupiterQuote] - A pre-fetched Jupiter quote to reuse
+ * @param {JupiterSwapQuote} [params.jupiterQuote] - A pre-fetched Jupiter quote to reuse
  * @return {Promise<{ ixs: TransactionInstruction[]; lookupTables: AddressLookupTableAccount[];
  *   method: 'jupiter' | 'marinade'; price?: number }>} Always resolves with `method: 'jupiter'`
  */
@@ -140,7 +140,7 @@ export declare function findBestJitoSolSuperStakeIxs({ amount, jupiterClient, ve
     velocityClient: VelocityClient;
     userAccountPublicKey?: PublicKey;
     onlyDirectRoutes?: boolean;
-    jupiterQuote?: QuoteResponse;
+    jupiterQuote?: JupiterSwapQuote;
 }): Promise<{
     ixs: TransactionInstruction[];
     lookupTables: AddressLookupTableAccount[];
@@ -161,7 +161,7 @@ export declare function findBestJitoSolSuperStakeIxs({ amount, jupiterClient, ve
  * @param {VelocityClient} params.velocityClient - Velocity client
  * @param {PublicKey} [params.userAccountPublicKey] - The target sub-account
  * @param {boolean} [params.onlyDirectRoutes] - Restrict Jupiter routing to direct swaps only
- * @param {QuoteResponse} [params.jupiterQuote] - A pre-fetched Jupiter quote to reuse
+ * @param {JupiterSwapQuote} [params.jupiterQuote] - A pre-fetched Jupiter quote to reuse
  * @return {Promise<{ ixs: TransactionInstruction[]; lookupTables: AddressLookupTableAccount[];
  *   method: 'jupiter' | 'marinade' }>} Always resolves with `method: 'jupiter'`
  */
@@ -173,7 +173,7 @@ export declare function findBestLstSuperStakeIxs({ amount, jupiterClient, veloci
     velocityClient: VelocityClient;
     userAccountPublicKey?: PublicKey;
     onlyDirectRoutes?: boolean;
-    jupiterQuote?: QuoteResponse;
+    jupiterQuote?: JupiterSwapQuote;
 }): Promise<{
     ixs: TransactionInstruction[];
     lookupTables: AddressLookupTableAccount[];

package/lib/browser/math/superStake.js

@@ -49,7 +49,7 @@ exports.fetchBSolVelocityEmissions = fetchBSolVelocityEmissions;
  * @param {boolean} [params.forceMarinade] - Force the direct Marinade stake path over a Jupiter
  *   swap even if Jupiter would be cheaper (market index 2 only)
  * @param {boolean} [params.onlyDirectRoutes] - Restrict Jupiter routing to direct swaps only
- * @param {QuoteResponse} [params.jupiterQuote] - A pre-fetched Jupiter quote to reuse instead of
+ * @param {JupiterSwapQuote} [params.jupiterQuote] - A pre-fetched Jupiter quote to reuse instead of
  *   fetching a fresh one
  * @return {Promise<{ ixs: TransactionInstruction[]; lookupTables: AddressLookupTableAccount[];
  *   method: 'jupiter' | 'marinade'; price?: number }>} The instructions to submit, any address
@@ -112,7 +112,7 @@ exports.findBestSuperStakeIxs = findBestSuperStakeIxs;
  * @param {PublicKey} [params.userAccountPublicKey] - The target sub-account
  * @param {boolean} [params.forceMarinade] - Force the Marinade path regardless of Jupiter pricing
  * @param {boolean} [params.onlyDirectRoutes] - Restrict Jupiter routing to direct swaps only
- * @param {QuoteResponse} [params.jupiterQuote] - A pre-fetched Jupiter quote to reuse
+ * @param {JupiterSwapQuote} [params.jupiterQuote] - A pre-fetched Jupiter quote to reuse
  * @return {Promise<{ ixs: TransactionInstruction[]; lookupTables: AddressLookupTableAccount[];
  *   method: 'jupiter' | 'marinade'; price: number }>} The chosen route's instructions, required
  *   lookup tables, the method used, and the mSOL/SOL price used for the decision
@@ -155,10 +155,10 @@ async function findBestMSolSuperStakeIxs({ amount, jupiterClient, velocityClient
         };
     }
     else {
-        const { ixs, lookupTables } = await velocityClient.getJupiterSwapIxV6({
+        const { ixs, lookupTables } = await velocityClient.getProviderSwapIx({
             inMarketIndex: 1,
             outMarketIndex: 2,
-            jupiterClient,
+            swapProvider: jupiterClient,
             amount,
             userAccountPublicKey,
             onlyDirectRoutes,
@@ -183,7 +183,7 @@ exports.findBestMSolSuperStakeIxs = findBestMSolSuperStakeIxs;
  * @param {VelocityClient} params.velocityClient - Velocity client
  * @param {PublicKey} [params.userAccountPublicKey] - The target sub-account
  * @param {boolean} [params.onlyDirectRoutes] - Restrict Jupiter routing to direct swaps only
- * @param {QuoteResponse} [params.jupiterQuote] - A pre-fetched Jupiter quote to reuse
+ * @param {JupiterSwapQuote} [params.jupiterQuote] - A pre-fetched Jupiter quote to reuse
  * @return {Promise<{ ixs: TransactionInstruction[]; lookupTables: AddressLookupTableAccount[];
  *   method: 'jupiter' | 'marinade'; price?: number }>} Always resolves with `method: 'jupiter'`
  */
@@ -214,15 +214,15 @@ exports.findBestJitoSolSuperStakeIxs = findBestJitoSolSuperStakeIxs;
  * @param {VelocityClient} params.velocityClient - Velocity client
  * @param {PublicKey} [params.userAccountPublicKey] - The target sub-account
  * @param {boolean} [params.onlyDirectRoutes] - Restrict Jupiter routing to direct swaps only
- * @param {QuoteResponse} [params.jupiterQuote] - A pre-fetched Jupiter quote to reuse
+ * @param {JupiterSwapQuote} [params.jupiterQuote] - A pre-fetched Jupiter quote to reuse
  * @return {Promise<{ ixs: TransactionInstruction[]; lookupTables: AddressLookupTableAccount[];
  *   method: 'jupiter' | 'marinade' }>} Always resolves with `method: 'jupiter'`
  */
 async function findBestLstSuperStakeIxs({ amount, jupiterClient, velocityClient, userAccountPublicKey, onlyDirectRoutes, lstMarketIndex, jupiterQuote, }) {
-    const { ixs, lookupTables } = await velocityClient.getJupiterSwapIxV6({
+    const { ixs, lookupTables } = await velocityClient.getProviderSwapIx({
         inMarketIndex: 1,
         outMarketIndex: lstMarketIndex,
-        jupiterClient,
+        swapProvider: jupiterClient,
         amount,
         userAccountPublicKey,
         onlyDirectRoutes,

package/lib/browser/swap/UnifiedSwapClient.d.ts

@@ -1,66 +1,23 @@
-import { Connection, PublicKey, TransactionMessage, AddressLookupTableAccount, VersionedTransaction, TransactionInstruction } from '@solana/web3.js';
-import { BN } from '../isomorphic/anchor';
+import { Connection, VersionedTransaction } from '@solana/web3.js';
 import { JupiterClient } from '../jupiter/jupiterClient';
 import { TitanClient } from '../titan/titanClient';
-export type SwapMode = 'ExactIn' | 'ExactOut';
-export type SwapClientType = 'jupiter' | 'titan';
+import { GetRouteInstructionsParams, SwapClientType, SwapProvider, SwapQuote, SwapQuoteParams, SwapRouteInstructions } from './types';
+export type { GetRouteInstructionsParams, SwapProviderRoute, SwapClientType, SwapMode, SwapProvider, SwapQuote, SwapQuoteParams, SwapRouteInstructions, UnifiedQuoteResponse, } from './types';
+/** Byte budget handed to a swap provider for the route portion of the tx. */
+export declare const DEFAULT_ROUTE_SIZE_CONSTRAINT: number;
 /**
- * Unified quote response interface that combines properties from both Jupiter and Titan
- * This provides a consistent interface while allowing for provider-specific fields
+ * Routes swap calls to the configured provider.
+ *
+ * Intentionally thin: it picks a provider and forwards. Anything that varies
+ * between Jupiter and Titan belongs in the provider, behind
+ * {@link SwapProvider} — branching on the provider here is how the two paths
+ * drifted apart previously, since nothing forced them to keep the same
+ * semantics.
  */
-export interface UnifiedQuoteResponse {
-    inputMint: string;
-    inAmount: string;
-    outputMint: string;
-    outAmount: string;
-    swapMode: SwapMode;
-    slippageBps: number;
-    routePlan: Array<{
-        swapInfo: any;
-        percent: number;
-    }>;
-    otherAmountThreshold?: string;
-    priceImpactPct?: string;
-    platformFee?: {
-        amount?: string;
-        feeBps?: number;
-    };
-    contextSlot?: number;
-    timeTaken?: number;
-    error?: string;
-    errorCode?: string;
-}
-export interface SwapQuoteParams {
-    inputMint: PublicKey;
-    outputMint: PublicKey;
-    amount: BN;
-    userPublicKey?: PublicKey;
-    maxAccounts?: number;
-    slippageBps?: number;
-    swapMode?: SwapMode;
-    onlyDirectRoutes?: boolean;
-    excludeDexes?: string[];
-    sizeConstraint?: number;
-    accountsLimitWritable?: number;
-    autoSlippage?: boolean;
-    maxAutoSlippageBps?: number;
-    usdEstimate?: number;
-}
-export interface SwapTransactionParams {
-    quote: UnifiedQuoteResponse;
-    userPublicKey: PublicKey;
-    slippageBps?: number;
-}
-export interface SwapTransactionResult {
-    transaction?: VersionedTransaction;
-    transactionMessage?: TransactionMessage;
-    lookupTables?: AddressLookupTableAccount[];
-}
-export declare class UnifiedSwapClient {
+export declare class UnifiedSwapClient implements SwapProvider {
     private client;
     private clientType;
     /**
-     * Create a unified swap client
      * @param clientType - 'jupiter' or 'titan'
      * @param connection - Solana connection
      * @param authToken - For Titan: auth token (required when not using proxy). For Jupiter: API key (required for api.jup.ag, get free key at https://portal.jup.ag)
@@ -74,32 +31,37 @@ export declare class UnifiedSwapClient {
         url?: string;
         proxyUrl?: string;
     });
+    get providerName(): SwapClientType;
+    /**
+     * The configured client, seen only as {@link SwapProvider}.
+     *
+     * Forwarding through the interface rather than the concrete union is what
+     * makes goal of this class enforceable: a provider added to the union that
+     * implements only part of the contract fails to compile here, instead of
+     * resolving against whichever call signatures the union happens to share.
+     */
+    private get provider();
     /**
-     * Get a swap quote from the underlying client
+     * Get a swap quote from the configured provider.
+     *
+     * Provider-specific fields on {@link SwapQuoteParams} are mapped by the
+     * provider, so the ones it doesn't recognise are simply ignored.
      */
-    getQuote(params: SwapQuoteParams): Promise<UnifiedQuoteResponse>;
+    getQuote(params: SwapQuoteParams): Promise<SwapQuote>;
     /**
-     * Get a swap transaction from the underlying client
+     * Builds the route instructions for a quote from {@link getQuote}, at the
+     * slippage that quote was priced at.
+     * @throws If the quote came from a different provider or a different wallet.
      */
-    getSwap(params: SwapTransactionParams): Promise<SwapTransactionResult>;
+    getRouteInstructions(params: GetRouteInstructionsParams): Promise<SwapRouteInstructions>;
     /**
-     * Get swap instructions from the underlying client (Jupiter or Titan)
-     * This is the core swap logic without any context preparation
+     * Builds a standalone swap transaction for a quote from {@link getQuote},
+     * keeping the provider's own compute budget, token account creation and SOL
+     * wrapping. Use {@link getRouteInstructions} for a swap that runs inside
+     * velocity's `beginSwap`/`endSwap` bracket.
+     * @throws If the quote came from a different provider or a different wallet.
      */
-    getSwapInstructions({ inputMint, outputMint, amount, userPublicKey, slippageBps, swapMode, onlyDirectRoutes, quote, sizeConstraint, }: {
-        inputMint: PublicKey;
-        outputMint: PublicKey;
-        amount: BN;
-        userPublicKey: PublicKey;
-        slippageBps?: number;
-        swapMode?: SwapMode;
-        onlyDirectRoutes?: boolean;
-        quote?: UnifiedQuoteResponse;
-        sizeConstraint?: number;
-    }): Promise<{
-        instructions: TransactionInstruction[];
-        lookupTables: AddressLookupTableAccount[];
-    }>;
+    getSwapTransaction(params: GetRouteInstructionsParams): Promise<VersionedTransaction>;
     /**
      * Get the underlying client instance
      */

package/lib/browser/swap/UnifiedSwapClient.js

@@ -1,11 +1,27 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.UnifiedSwapClient = void 0;
+exports.UnifiedSwapClient = exports.DEFAULT_ROUTE_SIZE_CONSTRAINT = 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. */
+exports.DEFAULT_ROUTE_SIZE_CONSTRAINT = utils_1.MAX_TX_BYTE_SIZE - VELOCITY_SWAP_IX_SIZE_BUFFER;
+/**
+ * Routes swap calls to the configured provider.
+ *
+ * Intentionally thin: it picks a provider and forwards. Anything that varies
+ * between Jupiter and Titan belongs in the provider, behind
+ * {@link SwapProvider} — branching on the provider here is how the two paths
+ * drifted apart previously, since nothing forced them to keep the same
+ * semantics.
+ */
 class UnifiedSwapClient {
     /**
-     * Create a unified swap client
      * @param clientType - 'jupiter' or 'titan'
      * @param connection - Solana connection
      * @param authToken - For Titan: auth token (required when not using proxy). For Jupiter: API key (required for api.jup.ag, get free key at https://portal.jup.ag)
@@ -33,123 +49,50 @@ class UnifiedSwapClient {
             throw new Error(`Unsupported client type: ${clientType}`);
         }
     }
+    get providerName() {
+        return this.clientType;
+    }
+    /**
+     * The configured client, seen only as {@link SwapProvider}.
+     *
+     * Forwarding through the interface rather than the concrete union is what
+     * makes goal of this class enforceable: a provider added to the union that
+     * implements only part of the contract fails to compile here, instead of
+     * resolving against whichever call signatures the union happens to share.
+     */
+    get provider() {
+        return this.client;
+    }
     /**
-     * Get a swap quote from the underlying client
+     * Get a swap quote from the configured provider.
+     *
+     * Provider-specific fields on {@link SwapQuoteParams} are mapped by the
+     * provider, so the ones it doesn't recognise are simply ignored.
      */
     async getQuote(params) {
-        if (this.clientType === 'jupiter') {
-            const jupiterClient = this.client;
-            const { userPublicKey: _userPublicKey, // Not needed for Jupiter
-            sizeConstraint: _sizeConstraint, // Jupiter-specific params to exclude
-            accountsLimitWritable: _accountsLimitWritable, ...jupiterParams } = params;
-            return await jupiterClient.getQuote(jupiterParams);
-        }
-        else {
-            const titanClient = this.client;
-            const { autoSlippage: _autoSlippage, // Titan-specific params to exclude
-            maxAutoSlippageBps: _maxAutoSlippageBps, usdEstimate: _usdEstimate, ...titanParams } = params;
-            if (!titanParams.userPublicKey) {
-                throw new Error('userPublicKey is required for Titan quotes');
-            }
-            // Cast to ensure TypeScript knows userPublicKey is defined
-            const titanParamsWithUser = {
-                ...titanParams,
-                userPublicKey: titanParams.userPublicKey,
-                swapMode: titanParams.swapMode, // Titan expects string
-                sizeConstraint: titanParams.sizeConstraint || 1280 - 375, // Use same default as getSwapInstructions
-            };
-            return await titanClient.getQuote(titanParamsWithUser);
-        }
+        var _a;
+        return this.provider.getQuote({
+            ...params,
+            sizeConstraint: (_a = params.sizeConstraint) !== null && _a !== void 0 ? _a : exports.DEFAULT_ROUTE_SIZE_CONSTRAINT,
+        });
     }
     /**
-     * Get a swap transaction from the underlying client
+     * Builds the route instructions for a quote from {@link getQuote}, at the
+     * slippage that quote was priced at.
+     * @throws If the quote came from a different provider or a different wallet.
      */
-    async getSwap(params) {
-        if (this.clientType === 'jupiter') {
-            const jupiterClient = this.client;
-            // Cast the quote to Jupiter's specific QuoteResponse type
-            const jupiterParams = {
-                ...params,
-                quote: params.quote,
-            };
-            const transaction = await jupiterClient.getSwap(jupiterParams);
-            return { transaction };
-        }
-        else {
-            const titanClient = this.client;
-            const { userPublicKey } = params;
-            // For Titan, we need to reconstruct the parameters from the quote
-            const result = await titanClient.getSwap({
-                userPublicKey,
-            });
-            return {
-                transactionMessage: result.transactionMessage,
-                lookupTables: result.lookupTables,
-            };
-        }
+    async getRouteInstructions(params) {
+        return this.provider.getRouteInstructions(params);
     }
     /**
-     * Get swap instructions from the underlying client (Jupiter or Titan)
-     * This is the core swap logic without any context preparation
+     * Builds a standalone swap transaction for a quote from {@link getQuote},
+     * keeping the provider's own compute budget, token account creation and SOL
+     * wrapping. Use {@link getRouteInstructions} for a swap that runs inside
+     * velocity's `beginSwap`/`endSwap` bracket.
+     * @throws If the quote came from a different provider or a different wallet.
      */
-    async getSwapInstructions({ inputMint, outputMint, amount, userPublicKey, slippageBps, swapMode = 'ExactIn', onlyDirectRoutes = false, quote, sizeConstraint, }) {
-        const isExactOut = swapMode === 'ExactOut';
-        let swapInstructions;
-        let lookupTables;
-        if (this.clientType === 'jupiter') {
-            const jupiterClient = this.client;
-            // Get quote if not provided
-            let finalQuote = quote;
-            if (!finalQuote) {
-                finalQuote = await jupiterClient.getQuote({
-                    inputMint,
-                    outputMint,
-                    amount,
-                    slippageBps,
-                    swapMode,
-                    onlyDirectRoutes,
-                });
-            }
-            if (!finalQuote) {
-                throw new Error('Could not fetch swap quote. Please try again.');
-            }
-            // Get swap transaction and extract instructions
-            const transaction = await jupiterClient.getSwap({
-                quote: finalQuote,
-                userPublicKey,
-                slippageBps,
-            });
-            const { transactionMessage, lookupTables: jupiterLookupTables } = await jupiterClient.getTransactionMessageAndLookupTables({
-                transaction,
-            });
-            swapInstructions = jupiterClient.getJupiterInstructions({
-                transactionMessage,
-                inputMint,
-                outputMint,
-            });
-            lookupTables = jupiterLookupTables;
-        }
-        else {
-            const titanClient = this.client;
-            // For Titan, get swap directly (it handles quote internally)
-            const { transactionMessage, lookupTables: titanLookupTables } = await titanClient.getSwap({
-                inputMint,
-                outputMint,
-                amount,
-                userPublicKey,
-                slippageBps,
-                swapMode: isExactOut ? titanClient_1.SwapMode.ExactOut : titanClient_1.SwapMode.ExactIn,
-                onlyDirectRoutes,
-                sizeConstraint: sizeConstraint || 1280 - 375, // MAX_TX_BYTE_SIZE - buffer for velocity instructions
-            });
-            swapInstructions = titanClient.getTitanInstructions({
-                transactionMessage,
-                inputMint,
-                outputMint,
-            });
-            lookupTables = titanLookupTables;
-        }
-        return { instructions: swapInstructions, lookupTables };
+    async getSwapTransaction(params) {
+        return this.provider.getSwapTransaction(params);
     }
     /**
      * Get the underlying client instance

package/lib/browser/swap/routeInstructions.d.ts

@@ -0,0 +1,19 @@
+import { PublicKey, TransactionInstruction } from '@solana/web3.js';
+/**
+ * Strips the setup and teardown a provider wraps around its route, leaving the
+ * instructions that go between `beginSwap` and `endSwap`.
+ *
+ * Velocity supplies its own compute budget, funds the input token account from
+ * the spot market vault, and sweeps the output back, so the provider's versions
+ * of all three are redundant. Its ATA creation for the input or output mint is
+ * dropped too, since velocity creates those itself; ATAs for any other mint
+ * (intermediate hops, fee accounts) are kept because nothing else creates them.
+ *
+ * Shared by both providers on purpose — when this lived in each client the two
+ * copies drifted, and the difference only showed up as a malformed transaction.
+ */
+export declare function filterRouteInstructions({ instructions, inputMint, outputMint, }: {
+    instructions: TransactionInstruction[];
+    inputMint: PublicKey;
+    outputMint: PublicKey;
+}): TransactionInstruction[];

package/lib/browser/swap/routeInstructions.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.filterRouteInstructions = void 0;
+const COMPUTE_BUDGET_PROGRAM_ID = 'ComputeBudget111111111111111111111111111111';
+const TOKEN_PROGRAM_ID = 'TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA';
+const SYSTEM_PROGRAM_ID = '11111111111111111111111111111111';
+const ASSOCIATED_TOKEN_PROGRAM_ID = 'ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL';
+/** Index of the mint in an associated-token-account instruction's key list. */
+const ATA_IX_MINT_KEY_INDEX = 3;
+/**
+ * Strips the setup and teardown a provider wraps around its route, leaving the
+ * instructions that go between `beginSwap` and `endSwap`.
+ *
+ * Velocity supplies its own compute budget, funds the input token account from
+ * the spot market vault, and sweeps the output back, so the provider's versions
+ * of all three are redundant. Its ATA creation for the input or output mint is
+ * dropped too, since velocity creates those itself; ATAs for any other mint
+ * (intermediate hops, fee accounts) are kept because nothing else creates them.
+ *
+ * Shared by both providers on purpose — when this lived in each client the two
+ * copies drifted, and the difference only showed up as a malformed transaction.
+ */
+function filterRouteInstructions({ instructions, inputMint, outputMint, }) {
+    return instructions.filter((instruction) => {
+        var _a;
+        const programId = instruction.programId.toString();
+        if (programId === COMPUTE_BUDGET_PROGRAM_ID ||
+            programId === TOKEN_PROGRAM_ID ||
+            programId === SYSTEM_PROGRAM_ID) {
+            return false;
+        }
+        if (programId === ASSOCIATED_TOKEN_PROGRAM_ID) {
+            // Guarded: a malformed ATA instruction with a short key list would
+            // otherwise throw here rather than simply being kept.
+            const mint = (_a = instruction.keys[ATA_IX_MINT_KEY_INDEX]) === null || _a === void 0 ? void 0 : _a.pubkey;
+            if (mint && (mint.equals(inputMint) || mint.equals(outputMint))) {
+                return false;
+            }
+        }
+        return true;
+    });
+}
+exports.filterRouteInstructions = filterRouteInstructions;