@shogun-sdk/intents-sdk 1.4.2 → 1.4.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shogun-sdk/intents-sdk",
-  "version": "1.4.2",
+  "version": "1.4.3",
   "type": "module",
   "description": "Shogun Network Intent-based cross-chain swaps SDK",
   "author": "Shogun network",
@@ -48,6 +48,7 @@
     "@types/node": "22.13.10",
     "codama": "1.3.4",
     "tsup": "^8.5.0",
+    "tsx": "^4.22.4",
     "typescript": "5.8.2",
     "vitest": "^2.1.9"
   },
@@ -92,6 +93,7 @@
     "pre-publish": "pnpm node ./scripts/prePublish.js",
     "generate-solana-idl": "pnpm node ./scripts/codama.js",
     "test": "vitest run",
-    "test:watch": "vitest"
+    "test:watch": "vitest",
+    "smoke:quote": "tsx scripts/net-quote-smoke.ts"
   }
 }

package/src/core/orders/cross-chain.ts

@@ -39,6 +39,8 @@ export type CreateCrossChainOrderParams = {
   deadline: number;
   /** Extra transfers to be made */
   extraTransfers?: ExtraTransfer[];
+  /** Slippage tolerance in bps for the auto-quote when min amounts are not provided. Defaults to DEFAULT_CROSS_CHAIN_SLIPPAGE_BPS (25) per swap leg. */
+  slippageBps?: number;
 
   /** Stop loss */
   stopLossType?: StopLossType;
@@ -168,12 +170,14 @@ export class CrossChainOrder {
 
     // TODO: Change this
     if (!minStablecoinAmount || !destinationTokenMinAmount) {
-      const quote = await QuoteProvider.getQuote({
+      const quote = await QuoteProvider.getCrossChainNetQuote({
         sourceChainId: input.sourceChainId,
         tokenIn: input.sourceTokenAddress,
         amount: input.sourceTokenAmount,
         destChainId: input.destinationChainId,
         tokenOut: input.destinationTokenAddress,
+        extraTransfers: input.extraTransfers,
+        slippageBps: input.slippageBps,
       });
 
       return {

package/src/core/orders/single-chain.ts

@@ -4,9 +4,6 @@ import type { ApiResponse } from '../../types/api.js';
 import type { SingleChainPreparedData, SingleChainUserIntentRequest } from '../../types/intent.js';
 import { SingleChainOrderValidator } from '../../utils/order-validator.js';
 import { QuoteProvider } from '../../utils/quote/aggregator.js';
-import { estimateAmountOut } from '../../utils/quote/pricing/estimate-amount-out.js';
-import { estimateExpensesInTokenOut } from '../../utils/quote/pricing/expenses.js';
-import { DEFAULT_COMMISSION_BPS, EVM_SINGLE_CHAIN_GAS_LIMIT, SINGLE_CHAIN_COMMISSION_DENOMINATOR } from '../../utils/quote/pricing/constants.js';
 import { getEVMSingleChainOrderTypedData } from '../evm/order-signature.js';
 import { BaseSDK } from '../sdk.js';
 import { getSolanaSingleChainOrderInstructions } from '../solana/order-instructions.js';
@@ -21,6 +18,8 @@ export type CreateSingleChainOrderParams = {
   destinationAddress: string;
   extraTransfers?: ExtraTransfer[];
   deadline: number;
+  /** Slippage tolerance in bps for the auto-quote when amountOutMin is not provided. Defaults to DEFAULT_SINGLE_CHAIN_SLIPPAGE_BPS (50). */
+  slippageBps?: number;
 
   stopLossType?: StopLossType;
   stopLossTriggerPrice?: string;
@@ -119,24 +118,15 @@ export class SingleChainOrder {
 
     switch (scenario) {
       case 'QUOTE_REQUIRED': {
-        const [quote, expenses] = await Promise.all([
-          QuoteProvider.getSingleChainQuote({
-            tokenIn: input.tokenIn,
-            amount: input.amountIn,
-            chainId: input.chainId,
-            tokenOut: input.tokenOut,
-          }),
-          estimateExpensesInTokenOut({
-            chainId: input.chainId,
-            tokenOut: input.tokenOut,
-            gasLimit: EVM_SINGLE_CHAIN_GAS_LIMIT,
-            getQuote: (p) => QuoteProvider.getSingleChainQuote(p),
-          }),
-        ]);
-
-        // Worst-case output already carries provider slippage; never use the nominal amountOut.
-        const swapOutput = quote.amountOutMin ?? quote.amountOut;
-        return estimateAmountOut(swapOutput, DEFAULT_COMMISSION_BPS, expenses, SINGLE_CHAIN_COMMISSION_DENOMINATOR);
+        const { netAmountOut } = await QuoteProvider.getSingleChainNetQuote({
+          chainId: input.chainId,
+          amount: input.amountIn,
+          tokenIn: input.tokenIn,
+          tokenOut: input.tokenOut,
+          extraTransfers: input.extraTransfers,
+          slippageBps: input.slippageBps,
+        });
+        return netAmountOut;
       }
 
       case 'USE_PROVIDED_AMOUNT':

package/src/index.ts

@@ -77,7 +77,16 @@ export { getSolanaDcaSingleChainOrderInstructions } from './core/solana/dca/crea
 export { signSingleChainDcaOrder } from './core/evm/single-chain-dca-order.js';
 export { signSingleChainLimitOrder } from './core/evm/single-chain-limit-order.js';
 
-export { QuoteProvider, type IntentsQuoteParams, type QuoteResponse } from './utils/quote/aggregator.js';
+export {
+  QuoteProvider,
+  type IntentsQuoteParams,
+  type QuoteResponse,
+  type Quote,
+  type SingleChainNetQuote,
+  type SingleChainNetQuoteParams,
+} from './utils/quote/aggregator.js';
+export { IntentNotViableError, type Expenses } from './utils/quote/pricing/estimate-amount-out.js';
+export { type ExtraTransferAmount } from './utils/quote/pricing/expenses.js';
 
 export { CROSS_CHAIN_GUARD_ADDRESSES, SINGLE_CHAIN_GUARD_ADDRESSES, PERMIT2_ADDRESS } from './constants.js';
 

package/src/utils/quote/aggregator.ts

@@ -10,9 +10,16 @@ import { RaydiumQuoteProvider, type RaydiumPumpQuoteParams, type RaydiumQuoteRes
 import { PumpFunQuoteProvider } from './pumpfun/index.js';
 import { RelayQuoteProvider } from './relay.js';
 import { convertDecimals } from './pricing/decimals.js';
-import { estimateAmountOut, IntentNotViableError } from './pricing/estimate-amount-out.js';
-import { estimateExpensesInTokenOut } from './pricing/expenses.js';
-import { DEFAULT_COMMISSION_BPS, CROSS_CHAIN_COMMISSION_DENOMINATOR, EVM_CROSS_CHAIN_GAS_LIMIT } from './pricing/constants.js';
+import { estimateAmountOut, IntentNotViableError, type Expenses } from './pricing/estimate-amount-out.js';
+import { estimateExpensesInTokenOut, type ExtraTransferAmount } from './pricing/expenses.js';
+import { exactInLimitAmount } from './pricing/limit-amount.js';
+import {
+  DEFAULT_COMMISSION_BPS,
+  CROSS_CHAIN_COMMISSION_DENOMINATOR,
+  SINGLE_CHAIN_COMMISSION_DENOMINATOR,
+  DEFAULT_SINGLE_CHAIN_SLIPPAGE_BPS,
+  DEFAULT_CROSS_CHAIN_SLIPPAGE_BPS,
+} from './pricing/constants.js';
 import { compareAddresses } from './address.js';
 
 type SingleChainQuoteParams = {
@@ -51,6 +58,9 @@ export type IntentsQuoteParams = {
   amount: bigint;
   tokenIn: string;
   tokenOut: string;
+  extraTransfers?: ExtraTransferAmount[];
+  /** Slippage tolerance in basis points, applied to both swap legs. Defaults to DEFAULT_CROSS_CHAIN_SLIPPAGE_BPS (25). */
+  slippageBps?: number;
 };
 
 export type QuoteResponseInternal = {
@@ -79,29 +89,110 @@ export type QuoteResponse = QuoteResponseInternal & {
   };
 };
 
+export type SingleChainNetQuoteParams = SingleChainQuoteParams & {
+  extraTransfers?: ExtraTransferAmount[];
+  protocolFeeInTokenOut?: bigint;
+};
+
+/** A single-chain quote plus the net amount the user receives after gas, extra transfers and commission. */
+export type SingleChainNetQuote = {
+  quote: Quote;
+  netAmountOut: bigint;
+  expenses: Expenses;
+};
+
 export class QuoteProvider {
+  /**
+   * Gross cross-chain quote: two nominal swap legs joined by the bridge stablecoin,
+   * with no solver expense model (no gas, commission or amount_limit haircuts).
+   * For the amount the solver will actually accept as amountOutMin, use
+   * getCrossChainNetQuote instead.
+   */
   public static async getQuote(params: IntentsQuoteParams): Promise<QuoteResponse> {
     try {
-      const quote = await this.getQuoteFromRouters(params);
-      // Adapt QuoteResponseInternal to QuoteResponse by adding tokenIn and tokenOut metadata fields
-      return {
-        ...quote,
-        tokenIn: {
-          address: params.tokenIn,
-          chainId: params.sourceChainId,
-        },
-        tokenOut: {
-          address: params.tokenOut,
-          chainId: params.destChainId,
-        },
-      };
+      return this.adaptQuoteResponse(await this.getGrossQuoteFromRouters(params), params);
     } catch (e) {
-      if (e instanceof IntentNotViableError) throw e;
       console.error('Error getting quote from routers:', e);
       throw new Error('Failed to get quote from routers');
     }
   }
 
+  /**
+   * Net cross-chain quote mirroring the solver's estimation exactly: swap legs credited
+   * at amount_limit, source/dest gas, commission and extra transfers subtracted from the
+   * bridged stablecoin amount. estimatedAmountOutReduced is the max amountOutMin the
+   * solver will accept; throws IntentNotViableError when expenses exceed a leg.
+   */
+  public static async getCrossChainNetQuote(params: IntentsQuoteParams): Promise<QuoteResponse> {
+    try {
+      return this.adaptQuoteResponse(await this.getNetQuoteFromRouters(params), params);
+    } catch (e) {
+      if (e instanceof IntentNotViableError) throw e;
+      console.error('Error getting net quote from routers:', e);
+      throw new Error('Failed to get net quote from routers');
+    }
+  }
+
+  /** Adds the tokenIn/tokenOut metadata fields QuoteResponse carries on top of the internal shape. */
+  private static adaptQuoteResponse(quote: QuoteResponseInternal, params: IntentsQuoteParams): QuoteResponse {
+    return {
+      ...quote,
+      tokenIn: {
+        address: params.tokenIn,
+        chainId: params.sourceChainId,
+      },
+      tokenOut: {
+        address: params.tokenOut,
+        chainId: params.destChainId,
+      },
+    };
+  }
+
+  /**
+   * The pre-solver-parity quote path: nominal source leg, decimal-normalized bridge,
+   * nominal dest leg. estimatedAmountOutReduced only reflects the dest provider's own
+   * amountOutMin when it reports one.
+   */
+  private static async getGrossQuoteFromRouters(params: IntentsQuoteParams): Promise<QuoteResponseInternal> {
+    const sourceStable = getStableForChain(params.sourceChainId);
+    const destStable = getStableForChain(params.destChainId);
+
+    // Step 1: quote tokenIn -> bridge stablecoin on the source chain
+    const sourceQuote = await this.getSingleChainQuote({
+      chainId: params.sourceChainId,
+      amount: params.amount,
+      tokenIn: params.tokenIn,
+      tokenOut: sourceStable.address,
+      slippageBps: params.slippageBps,
+    });
+
+    // Step 2: normalize decimals between source and destination stablecoins
+    const normalizedBridgeAmount = convertDecimals(sourceQuote.amountOut, sourceStable.decimals, destStable.decimals);
+
+    // Step 3: quote bridge stablecoin -> target token on the dest chain
+    const destQuote = await this.getSingleChainQuote({
+      chainId: params.destChainId,
+      amount: normalizedBridgeAmount,
+      tokenIn: destStable.address,
+      tokenOut: params.tokenOut,
+      slippageBps: params.slippageBps,
+    });
+
+    // Step 4: stablecoin min-amount from the source leg's USD value
+    const estimatedAmountInAsMinStablecoinAmount = BigInt(
+      Math.floor(sourceQuote.amountInUsd * 10 ** sourceStable.decimals),
+    );
+
+    return {
+      estimatedAmountOut: destQuote.amountOut,
+      estimatedAmountOutUsd: destQuote.amountOutUsd,
+      amountInUsd: sourceQuote.amountInUsd,
+      estimatedAmountInAsMinStablecoinAmount,
+      estimatedAmountOutReduced: destQuote.amountOutMin || destQuote.amountOut,
+      estimatedAmountOutUsdReduced: destQuote.amountOutUsd,
+    };
+  }
+
   /**
    * Get a quote for Solana with explicit provider selection
    * @param params - Quote parameters including provider preference
@@ -126,58 +217,77 @@ export class QuoteProvider {
     return this.getSingleChainQuote(singleChainParams);
   }
 
-  private static async getQuoteFromRouters(params: IntentsQuoteParams): Promise<QuoteResponseInternal> {
+  private static async getNetQuoteFromRouters(params: IntentsQuoteParams): Promise<QuoteResponseInternal> {
     const sourceStable = getStableForChain(params.sourceChainId);
     const destStable = getStableForChain(params.destChainId);
-
-    //  Step 1: Get quote from tokenIn → bridge stable on source chain ---
-    const sourceSingleChainQuoteParams: SingleChainQuoteParams = {
-      chainId: params.sourceChainId,
-      amount: params.amount,
-      tokenIn: params.tokenIn,
-      tokenOut: sourceStable.address,
-    };
-
-    const [sourceQuote, expenses] = await Promise.all([
-      this.getSingleChainQuote(sourceSingleChainQuoteParams),
+    const getQuote = (p: SingleChainQuoteParams) => this.getSingleChainQuote(p);
+    const sourceIsStable = compareAddresses(params.tokenIn, sourceStable.address);
+    const destIsStable = compareAddresses(params.tokenOut, destStable.address);
+
+    // Steps 1-2 & 4 inputs are independent (source quote, source-leg gas, dest-leg gas + extra
+    // transfers depend only on params), so fetch them concurrently; only the dest swap must wait.
+    const [sourceQuote, sourceExpenses, destExpenses] = await Promise.all([
+      // Step 1: source quote tokenIn -> source stablecoin
+      this.getSingleChainQuote({
+        chainId: params.sourceChainId,
+        amount: params.amount,
+        tokenIn: params.tokenIn,
+        tokenOut: sourceStable.address,
+        slippageBps: params.slippageBps ?? DEFAULT_CROSS_CHAIN_SLIPPAGE_BPS,
+      }),
+      // Step 2 input: source-chain gas valued in the source stablecoin. A stablecoin
+      // token_in needs no source swap, so the solver charges start_without_swap gas.
+      estimateExpensesInTokenOut({
+        chainId: params.sourceChainId,
+        tokenOut: sourceStable.address,
+        getQuote,
+        flow: sourceIsStable ? 'crossChainSourceNoSwap' : 'crossChainSource',
+      }),
+      // Step 4 input: dest gas + extra transfers valued in the dest stablecoin
       estimateExpensesInTokenOut({
         chainId: params.destChainId,
-        tokenOut: params.tokenOut,
-        gasLimit: EVM_CROSS_CHAIN_GAS_LIMIT,
-        getQuote: (p) => this.getSingleChainQuote(p),
+        tokenOut: destStable.address,
+        getQuote,
+        extraTransfers: params.extraTransfers,
+        flow: 'crossChainDest',
       }),
     ]);
 
-    // Step 2: Normalize stable amount between source and destination ---
-    // Adjust for decimal difference between stables (e.g. 6 → 18)
-    const normalizedBridgeAmount = convertDecimals(
-      sourceQuote.amountOut,
-      sourceStable.decimals,
-      destStable.decimals,
+    // Step 2: subtract source-chain gas from the source leg, crediting the swap at
+    // amount_limit like the solver (cross_chain_estimation.rs:155). When token_in is
+    // already the stablecoin the solver's router short-circuits 1:1 (SimpleTransfer,
+    // estimate.rs:141-157) with no slippage haircut.
+    // commission 0 here: the solver applies commission only on the destination leg
+    const sourceStableOut = sourceIsStable ? sourceQuote.amountOut : exactInLimitAmount(sourceQuote.amountOut);
+    const sourceStableAfterGas = estimateAmountOut(sourceStableOut, 0n, sourceExpenses);
+
+    // Step 3: normalize decimals between source and destination stablecoins
+    const normalizedBridgeAmount = convertDecimals(sourceStableAfterGas, sourceStable.decimals, destStable.decimals);
+
+    // Step 4: subtract commission + dest gas + extra transfers on the bridged stablecoin amount
+    const bridgedNet = estimateAmountOut(
+      normalizedBridgeAmount,
+      DEFAULT_COMMISSION_BPS,
+      destExpenses,
+      CROSS_CHAIN_COMMISSION_DENOMINATOR,
     );
 
-    // Step 3: Get quote from dest bridge stable → target token ---
-    const destSingleChainQuoteParams: SingleChainQuoteParams = {
+    // Step 5: swap the net bridged stablecoin amount into the target token
+    const destQuote = await this.getSingleChainQuote({
       chainId: params.destChainId,
-      amount: normalizedBridgeAmount,
+      amount: bridgedNet,
       tokenIn: destStable.address,
       tokenOut: params.tokenOut,
-    };
-
-    const destQuote = await this.getSingleChainQuote(destSingleChainQuoteParams);
+      slippageBps: params.slippageBps ?? DEFAULT_CROSS_CHAIN_SLIPPAGE_BPS,
+    });
 
-    // Step 4: Compute stable min-amount with correct decimals ---
-    const estimatedAmountInAsMinStablecoinAmount = BigInt(
-      Math.floor(sourceQuote.amountInUsd * 10 ** sourceStable.decimals),
-    );
+    // Step 6: stablecoin min-amount — the solver accepts a --min-stablecoins floor only up
+    // to its own source-swap amount_limit (ws/helpers/mod.rs:32-51), so expose exactly that.
+    const estimatedAmountInAsMinStablecoinAmount = sourceStableOut;
 
-    const swapOutput = destQuote.amountOutMin ?? destQuote.amountOut;
-    const estimatedAmountOutReduced = estimateAmountOut(
-      swapOutput,
-      DEFAULT_COMMISSION_BPS,
-      expenses,
-      CROSS_CHAIN_COMMISSION_DENOMINATOR,
-    );
+    // The solver's max deliverable is the dest swap's amount_limit (cross_chain_estimation.rs:243),
+    // 1:1 when token_out is the stablecoin itself (SimpleTransfer short-circuit).
+    const estimatedAmountOutReduced = destIsStable ? destQuote.amountOut : exactInLimitAmount(destQuote.amountOut);
 
     return {
       estimatedAmountOut: destQuote.amountOut,
@@ -270,6 +380,25 @@ export class QuoteProvider {
     throw new Error(`Unsupported chain for quote: ${params.chainId}`);
   }
 
+  public static async getSingleChainNetQuote(params: SingleChainNetQuoteParams): Promise<SingleChainNetQuote> {
+    const [quote, expenses] = await Promise.all([
+      this.getSingleChainQuote(params),
+      estimateExpensesInTokenOut({
+        chainId: params.chainId,
+        tokenOut: params.tokenOut,
+        getQuote: (p) => this.getSingleChainQuote(p),
+        extraTransfers: params.extraTransfers,
+        protocolFeeInTokenOut: params.protocolFeeInTokenOut,
+        flow: 'singleChain',
+      }),
+    ]);
+    // The solver credits the swap at amount_limit (nominal minus DEFAULT_SLIPPAGE, rounded
+    // up), regardless of any amountOutMin our provider reports — mirror that exactly.
+    const swapOutput = exactInLimitAmount(quote.amountOut);
+    const netAmountOut = estimateAmountOut(swapOutput, DEFAULT_COMMISSION_BPS, expenses, SINGLE_CHAIN_COMMISSION_DENOMINATOR);
+    return { quote, netAmountOut, expenses };
+  }
+
   static transformLiquidSwapQuote(liquidSwapQuote: LiquidSwapQuoteResponse): Quote {
     return {
       amountIn: liquidSwapQuote.execution.details.amountIn,
@@ -319,7 +448,7 @@ export class QuoteProvider {
       tokenIn: params.tokenIn,
       tokenOut: params.tokenOut,
       swapMode: 'ExactIn',
-      slippageBps: params.slippageBps ? params.slippageBps : 20, // Default 0.2% slippage
+      slippageBps: params.slippageBps ? params.slippageBps : DEFAULT_SINGLE_CHAIN_SLIPPAGE_BPS,
     });
   }
 
@@ -360,7 +489,7 @@ export class QuoteProvider {
       inputMint: params.tokenIn,
       outputMint: params.tokenOut,
       amount: params.amount.toString(),
-      slippageBps: params.slippageBps || 20, // Default 0.2% slippage
+      slippageBps: params.slippageBps || DEFAULT_SINGLE_CHAIN_SLIPPAGE_BPS,
     };
     try {
       return this.transformRaydiumQuote(await raydiumQuoter.getQuote(request));
@@ -377,7 +506,7 @@ export class QuoteProvider {
       inputMint: params.tokenIn,
       outputMint: params.tokenOut,
       amount: params.amount.toString(),
-      slippageBps: params.slippageBps || 20, // Default 0.2% slippage
+      slippageBps: params.slippageBps || DEFAULT_SINGLE_CHAIN_SLIPPAGE_BPS,
     };
     return simpleQuoteToQuote(await pumpfunQuoter.getQuote(request), 'pumpfun');
   }

package/src/utils/quote/pricing/constants.ts

@@ -4,7 +4,20 @@ import { ChainID } from '../../../chains.js';
  * Solver commission in basis points. MUST equal the solver's COMMISSION env value
  * (solver/src/config.rs). Update both together to avoid quote divergence.
  */
-export const DEFAULT_COMMISSION_BPS = 50n; // 0.5% — placeholder, confirm against solver COMMISSION
+export const DEFAULT_COMMISSION_BPS = 0n; // mirrors solver production COMMISSION=0 (environment/production.yaml)
+
+/**
+ * The solver's DEFAULT_SLIPPAGE=0.05% (environment/production.yaml) in bps. Applied via
+ * get_limit_amount (swap_estimator_rust/src/utils/limit_amount.rs): subtracted from swap
+ * outputs (ExactIn) and added to every expense valuation (ExactOut) — see limit-amount.ts.
+ */
+export const SOLVER_DEFAULT_SLIPPAGE_BPS = 5n;
+
+/** Default slippage tolerance (bps) for single-chain quotes when the caller does not provide one. */
+export const DEFAULT_SINGLE_CHAIN_SLIPPAGE_BPS = 50;
+
+/** Default slippage tolerance (bps) applied to each cross-chain swap leg when the caller does not provide one. */
+export const DEFAULT_CROSS_CHAIN_SLIPPAGE_BPS = 25;
 
 /** Single-chain divisor — mirrors evaluate.rs:130-131 (`commission / 10_000`). */
 export const SINGLE_CHAIN_COMMISSION_DENOMINATOR = 10_000n;
@@ -19,15 +32,46 @@ export const CROSS_CHAIN_COMMISSION_DENOMINATOR = 100_000n;
 /** EVM fulfillment gas units — mirrors solver/src/constants/chains.rs (EVM single-chain). */
 export const EVM_SINGLE_CHAIN_GAS_LIMIT = 3_000_000n;
 
-/** EVM cross-chain fulfillment gas units — mirrors solver/src/constants/chains.rs (EVM cross-chain). */
+/** EVM cross-chain fulfillment (DEST-leg) gas units — mirrors solver/src/constants/chains.rs (EVM cross-chain). */
 export const EVM_CROSS_CHAIN_GAS_LIMIT = 2_000_000n;
 
 /**
- * Fixed native-token gas cost for non-EVM chains, in the chain's smallest unit.
- * Mirrors solver/src/constants/chains.rs: Sui = 20_000_000 MIST; Solana base = 200_000 lamports
- * (single-receiver default; per-receiver ATA cost is not modeled at quote time).
+ * EVM cross-chain SOURCE-leg gas units — mirrors solver chains.rs:
+ * start_order_execution_with_swap_cost (1_000_000) + claim_tokens_cost (220_000).
+ * The DEST-leg fulfill cost is EVM_CROSS_CHAIN_GAS_LIMIT above.
+ */
+export const EVM_CROSS_CHAIN_SOURCE_GAS_LIMIT = 1_220_000n;
+
+/**
+ * SOURCE-leg gas units when no source swap is needed (token_in already whitelisted /
+ * the stablecoin): start_order_execution_without_swap_cost (400_000) + claim (220_000).
+ */
+export const EVM_CROSS_CHAIN_SOURCE_NO_SWAP_GAS_LIMIT = 620_000n;
+
+/**
+ * Safety margin applied to the execution-price component of gas, on top of the
+ * solver-mirror math: the live EVM gas price (the solver evaluates with an eth_gasPrice
+ * cached for up to 10 minutes — observed +33% above our live reading on Base) and the
+ * Solana transaction/tip costs. Solana rent-exempt account creation (ATA, escrow PDA)
+ * is runtime-fixed and NOT padded. Over-provisioning keeps the signed amountOutMin
+ * below the solver's max when its gas figure drifts above ours.
+ */
+export const GAS_PRICE_SAFETY_MARGIN_BPS = 2_000n; // +20%
+
+/**
+ * Fixed native-token gas cost for non-EVM chains without a per-flow formula, in the
+ * chain's smallest unit. Sui mirrors the solver's single-chain flat 20_000_000 MIST
+ * (solver/src/constants/chains.rs); its cross-chain formula is smaller, so this
+ * overstates conservatively. Solana is computed per flow in gas.ts instead.
  */
 export const NON_EVM_FIXED_NATIVE_GAS_COST: Partial<Record<ChainID, bigint>> = {
   [ChainID.Sui]: 20_000_000n,
-  [ChainID.Solana]: 200_000n,
 };
+
+/** Solana cost components (lamports) — mirror solver chains.rs and constants/mod.rs (gas_price = 1). */
+export const SOLANA_CREATE_ATA_COST = 2_050_000n;
+export const SOLANA_CREATE_EMPTY_ACC_COST = 890_880n;
+export const SOLANA_JITO_TIP = 500_000n; // solver DEFAULT_JITO_TIP
+export const SOLANA_BASE_TX_COST = 200_000n;
+export const SOLANA_CLAIM_TOKENS_COST = 300_000n;
+export const SOLANA_START_WITHOUT_SWAP_COST = 300_000n; // start_order_execution_without_swap_cost

package/src/utils/quote/pricing/expenses.ts

@@ -3,11 +3,17 @@ import {
   NATIVE_EVM_ETH_ADDRESSES,
   NATIVE_SOLANA_TOKEN_ADDRESS,
   NATIVE_SUI_TOKEN_ADDRESS,
+  WRAPPED_ETH_ADDRESSES,
+  WRAPPED_SOL_MINT_ADDRESS,
   isNativeEvmToken,
 } from '../../../constants.js';
 import { compareAddresses } from '../address.js';
 import type { Expenses } from './estimate-amount-out.js';
-import { getNativeGasCost } from './gas.js';
+import { getNativeGasCost, type GasFlow } from './gas.js';
+import { exactOutLimitAmount } from './limit-amount.js';
+
+/** An extra transfer as the pricing layer sees it — token and amount only, no receiver. */
+export type ExtraTransferAmount = { token: string; amount: bigint };
 
 /** Quotes a native->tokenOut swap on the given chain. Injected to keep this module a leaf (no dependency on the aggregator). */
 type GasQuoteFn = (params: {
@@ -25,38 +31,88 @@ function nativeTokenAddressForChain(chainId: SupportedChain): string {
   return NATIVE_EVM_ETH_ADDRESSES[0]!;
 }
 
-function isNativeToken(chainId: SupportedChain, address: string): boolean {
-  if (chainId === ChainID.Solana) return compareAddresses(address, NATIVE_SOLANA_TOKEN_ADDRESS);
+/**
+ * True when 1 native smallest-unit equals 1 unit of `address`: the native token itself
+ * or its canonical wrapped form (wrapping is 1:1, and routers have no "route" for it,
+ * so quoting native->wrapped would fail despite being trivially priceable).
+ */
+function isNativeOrWrappedNative(chainId: SupportedChain, address: string): boolean {
+  if (chainId === ChainID.Solana) {
+    return (
+      compareAddresses(address, NATIVE_SOLANA_TOKEN_ADDRESS) || compareAddresses(address, WRAPPED_SOL_MINT_ADDRESS)
+    );
+  }
   if (chainId === ChainID.Sui) return compareAddresses(address, NATIVE_SUI_TOKEN_ADDRESS);
-  return isNativeEvmToken(address);
+  return isNativeEvmToken(address) || compareAddresses(address, WRAPPED_ETH_ADDRESSES[chainId]);
 }
 
 /**
  * Builds the Expenses bundle in the output token. Gas is fetched in native units and
  * swapped into tokenOut via the injected quote fn, mirroring how the solver converts
- * expenses into the output token. protocolFee/extraTransfers are reserved (0n) for now.
+ * expenses into the output token. Extra transfers (e.g. relayer/affiliate payouts) are
+ * taken 1:1 when already denominated in tokenOut, or quoted otherwise.
+ *
+ * Padding mirrors the flow's solver code path:
+ * - single-chain applies get_limit_amount(ExactOut) uniformly to every expense conversion
+ *   (evaluate.rs:116-128), even same-token / native-wrapped short-circuits — pad everything;
+ * - cross-chain values expenses via estimate_tokens_value_in_stablecoins
+ *   (cross_chain_estimation.rs:452-475), which adds stablecoin-denominated amounts directly
+ *   and pads only USD-converted ones — leave amounts already in tokenOut unpadded.
  */
 export async function estimateExpensesInTokenOut(params: {
   chainId: SupportedChain;
   tokenOut: string;
-  gasLimit: bigint;
   getQuote: GasQuoteFn;
+  extraTransfers?: ExtraTransferAmount[];
+  protocolFeeInTokenOut?: bigint;
+  flow?: GasFlow;
   rpcProviderUrl?: string;
 }): Promise<Expenses> {
-  const { chainId, tokenOut, gasLimit, getQuote, rpcProviderUrl } = params;
-
-  const nativeGasCost = await getNativeGasCost({ chainId, gasLimit, rpcProviderUrl });
-
-  const gasInTokenOut = isNativeToken(chainId, tokenOut)
-    ? nativeGasCost
-    : (
-        await getQuote({
-          chainId,
-          amount: nativeGasCost,
-          tokenIn: nativeTokenAddressForChain(chainId),
-          tokenOut,
-        })
-      ).amountOut;
-
-  return { gasInTokenOut, protocolFeeInTokenOut: 0n, extraTransfersInTokenOut: 0n };
+  const { chainId, tokenOut, getQuote, extraTransfers, protocolFeeInTokenOut, flow, rpcProviderUrl } = params;
+  const padDirectAmounts = (flow ?? 'singleChain') === 'singleChain';
+  const padDirect = (amount: bigint) => (padDirectAmounts ? exactOutLimitAmount(amount) : amount);
+
+  // Value each extra transfer in tokenOut concurrently with the gas legs — they share no inputs.
+  // Those already in tokenOut skip the quote.
+  const extraTransfersPromise = Promise.all(
+    (extraTransfers ?? []).map((transfer) =>
+      compareAddresses(transfer.token, tokenOut)
+        ? Promise.resolve(padDirect(transfer.amount))
+        : getQuote({ chainId, amount: transfer.amount, tokenIn: transfer.token, tokenOut }).then((q) =>
+            exactOutLimitAmount(q.amountOut),
+          ),
+    ),
+  );
+  // Register a handler so a transfer-quote rejection is not reported as unhandled
+  // if the gas leg throws first; the await below still surfaces the error.
+  extraTransfersPromise.catch(() => {});
+
+  // Worst-case receiver count: destination address plus one distinct receiver per extra
+  // transfer — mirrors the solver's max_cost_of_accounts_creation (Solana ATA per receiver).
+  const uniqueReceivers = 1 + (extraTransfers?.length ?? 0);
+  const nativeGasCost = await getNativeGasCost({ chainId, flow, uniqueReceivers, rpcProviderUrl });
+
+  // A zero-amount swap always yields zero out, so skip the quote call entirely
+  // rather than round-tripping to the quoting service for nothing.
+  const gasInTokenOut = exactOutLimitAmount(
+    isNativeOrWrappedNative(chainId, tokenOut) || nativeGasCost === 0n
+      ? nativeGasCost
+      : (
+          await getQuote({
+            chainId,
+            amount: nativeGasCost,
+            tokenIn: nativeTokenAddressForChain(chainId),
+            tokenOut,
+          })
+        ).amountOut,
+  );
+
+  const extraTransferAmounts = await extraTransfersPromise;
+  const extraTransfersInTokenOut = extraTransferAmounts.reduce((sum, amount) => sum + amount, 0n);
+
+  return {
+    gasInTokenOut,
+    protocolFeeInTokenOut: padDirect(protocolFeeInTokenOut ?? 0n),
+    extraTransfersInTokenOut,
+  };
 }