@shogun-sdk/intents-sdk 1.2.6-test.15 → 1.2.6-test.16

package/src/core/solana/dca/create-order.ts

@@ -35,16 +35,14 @@ import {
 import { ChainID } from '../../../chains.js';
 import { getTransferSolInstruction } from '@solana-program/system';
 import { getCreateDcaOrderInstructionAsync } from '../generated/single-chain/index.js';
-import { resolveSolanaFeePayer, resolveSolanaTip, type SolanaTransactionOptions } from '../transaction-options.js';
 
 export async function getSolanaDcaSingleChainOrderInstructions(
   order: DcaSingleChainOrder,
-  options?: SolanaTransactionOptions,
+  options?: { rpcUrl?: string },
 ): Promise<SolanaOrderInstructionResult & { secretNumber: string }> {
   const rpc = options?.rpcUrl ? createSolanaRpc(options.rpcUrl) : getDefaultSolanaRPC();
   const orderSigner = await generateKeyPairSigner();
-  const userSigner = createNoopSigner(order.user as Address);
-  const feePayerSigner = resolveSolanaFeePayer(userSigner, options?.feePayer);
+  const signer = createNoopSigner(order.user as Address);
 
   let tokenInMint = address(order.tokenIn);
 
@@ -76,7 +74,7 @@ export async function getSolanaDcaSingleChainOrderInstructions(
 
   if (!userTokenInAccount.exists) {
     const createAccountIx = await getCreateAssociatedTokenInstructionAsync({
-      payer: feePayerSigner,
+      payer: signer,
       ata: tokenInProgramAccount,
       owner: orderUserAddress,
       mint: tokenMintProgram.address,
@@ -92,7 +90,7 @@ export async function getSolanaDcaSingleChainOrderInstructions(
     const transferIx = getTransferSolInstruction({
       amount: totalAmountIn,
       destination: userTokenInAccount.address,
-      source: userSigner,
+      source: signer,
     });
 
     instructions.push(transferIx);
@@ -105,7 +103,7 @@ export async function getSolanaDcaSingleChainOrderInstructions(
   }
 
   const createDcaOrderIx = await getCreateDcaOrderInstructionAsync({
-    user: userSigner,
+    user: signer,
     order: orderSigner,
     guard: guardAddress,
     tokenInMint: tokenInMint,
@@ -121,23 +119,12 @@ export async function getSolanaDcaSingleChainOrderInstructions(
   });
 
   instructions.push(createDcaOrderIx);
-  const tip = resolveSolanaTip(options);
-
-  if (tip) {
-    instructions.push(
-      getTransferSolInstruction({
-        source: feePayerSigner,
-        destination: tip.account,
-        amount: tip.lamports,
-      }),
-    );
-  }
 
   const { value: latestBlockhash } = await rpc.getLatestBlockhash({ commitment: 'confirmed' }).send();
 
   const txMessage = pipe(
     createTransactionMessage({ version: 0 }),
-    (tx) => setTransactionMessageFeePayerSigner(feePayerSigner, tx),
+    (tx) => setTransactionMessageFeePayerSigner(signer, tx),
     (tx) => setTransactionMessageLifetimeUsingBlockhash(latestBlockhash, tx),
     (tx) => appendTransactionMessageInstructions(instructions, tx),
     (tx) => addSignersToTransactionMessage([orderSigner], tx),

package/src/core/solana/intent-helpers.ts

@@ -10,7 +10,6 @@ import type { DcaSingleChainOrder } from '../orders/dca-single-chain.js';
 import type { ExtraTransfer, StopLossType } from '../orders/common.js';
 import { getSolanaCrossChainOrderInstructions, getSolanaSingleChainOrderInstructions } from './order-instructions.js';
 import { getSolanaDcaSingleChainOrderInstructions } from './dca/create-order.js';
-import type { SolanaTransactionOptions } from './transaction-options.js';
 import { prepareDcaSecretData } from './dca/single-chain-dca-order.js';
 import { prepareSecretData } from './dca/single-chain-limit-order.js';
 import { generateExecutionDetailsHash } from '../../utils/generate-execution-details-hash.js';
@@ -61,7 +60,8 @@ export type CreateSolanaCrossChainOrderIntentParams = {
   deadline: number;
   extraTransfers?: ExtraTransfer[];
   orderPubkey?: string;
-  stopLossMaxOut?: bigint;
+  stopLossType?: StopLossType;
+  stopLossTriggerPrice?: string;
   takeProfitMinOut?: bigint;
 };
 
@@ -151,13 +151,14 @@ export function createSolanaCrossChainOrderIntentRequest(
     amountOutMin: params.destinationTokenMinAmount?.toString() || '1',
     destinationAddress: params.destinationAddress,
     extraTransfers: params.extraTransfers,
-    stopLossMaxOut: params.stopLossMaxOut?.toString(),
+    stopLossType: params.stopLossType,
+    stopLossTriggerPrice: params.stopLossTriggerPrice,
     takeProfitMinOut: params.takeProfitMinOut?.toString(),
   };
   const executionDetailsString = JSON.stringify(executionDetails, Parsers.bigIntReplacer);
 
-  // Calculate execution details hash
-  const executionDetailsHash = generateExecutionDetailsHash(executionDetails);
+  // Hash the exact string we send; the auctioneer recomputes sha256 over it and rejects on mismatch
+  const executionDetailsHash = generateExecutionDetailsHash(executionDetailsString);
 
   const genericData = {
     user: params.user,
@@ -186,11 +187,8 @@ export function createSolanaCrossChainOrderIntentRequest(
  * @param order The single-chain order
  * @returns Promise resolving to instruction bytes
  */
-export async function generateSolanaSingleChainLimitOrderInstructions(
-  order: SingleChainOrder,
-  options?: SolanaTransactionOptions,
-) {
-  return getSolanaSingleChainOrderInstructions(order, options);
+export async function generateSolanaSingleChainLimitOrderInstructions(order: SingleChainOrder) {
+  return getSolanaSingleChainOrderInstructions(order);
 }
 
 /**
@@ -198,11 +196,8 @@ export async function generateSolanaSingleChainLimitOrderInstructions(
  * @param order The DCA order
  * @returns Promise resolving to instruction bytes
  */
-export async function generateSolanaSingleChainDcaOrderInstructions(
-  order: DcaSingleChainOrder,
-  options?: SolanaTransactionOptions,
-) {
-  return getSolanaDcaSingleChainOrderInstructions(order, options);
+export async function generateSolanaSingleChainDcaOrderInstructions(order: DcaSingleChainOrder) {
+  return getSolanaDcaSingleChainOrderInstructions(order);
 }
 
 /**
@@ -210,11 +205,8 @@ export async function generateSolanaSingleChainDcaOrderInstructions(
  * @param order The cross-chain order
  * @returns Promise resolving to instruction bytes
  */
-export async function generateSolanaCrossChainOrderInstructions(
-  order: CrossChainOrder,
-  options?: SolanaTransactionOptions,
-) {
-  return getSolanaCrossChainOrderInstructions(order, options);
+export async function generateSolanaCrossChainOrderInstructions(order: CrossChainOrder) {
+  return getSolanaCrossChainOrderInstructions(order);
 }
 
 /**

package/src/core/solana/order-instructions.ts

@@ -38,7 +38,6 @@ import { getDefaultSolanaRPC } from './client.js';
 import { getCreateOrderInstruction } from './generated/cross-chain/index.js';
 import { getCreateLimitOrderInstructionAsync } from './generated/single-chain/index.js';
 import { genSecretHashAndNumber } from './utils.js';
-import { resolveSolanaFeePayer, resolveSolanaTip, type SolanaTransactionOptions } from './transaction-options.js';
 
 export type SolanaOrderInstructionResult = {
   // Order address
@@ -49,12 +48,11 @@ export type SolanaOrderInstructionResult = {
 
 export async function getSolanaSingleChainOrderInstructions(
   order: SingleChainOrder,
-  options?: SolanaTransactionOptions,
+  options?: { rpcUrl?: string },
 ): Promise<SolanaOrderInstructionResult & { secretNumber: string }> {
   const rpc = options?.rpcUrl ? createSolanaRpc(options.rpcUrl) : getDefaultSolanaRPC();
   const orderSigner = await generateKeyPairSigner();
-  const userSigner = createNoopSigner(order.user as Address);
-  const feePayerSigner = resolveSolanaFeePayer(userSigner, options?.feePayer);
+  const signer = createNoopSigner(order.user as Address);
 
   let tokenInMint = address(order.tokenIn);
 
@@ -86,7 +84,7 @@ export async function getSolanaSingleChainOrderInstructions(
 
   if (!userTokenInAccount.exists) {
     const createAccountIx = await getCreateAssociatedTokenInstructionAsync({
-      payer: feePayerSigner,
+      payer: signer,
       ata: tokenInProgramAccount,
       owner: orderUserAddress,
       mint: tokenMintProgram.address,
@@ -100,7 +98,7 @@ export async function getSolanaSingleChainOrderInstructions(
     const transferIx = getTransferSolInstruction({
       amount: order.amountIn,
       destination: userTokenInAccount.address,
-      source: userSigner,
+      source: signer,
     });
 
     instructions.push(transferIx);
@@ -113,7 +111,7 @@ export async function getSolanaSingleChainOrderInstructions(
   }
 
   const createSingleChainLimitOrderIx = await getCreateLimitOrderInstructionAsync({
-    user: userSigner,
+    user: signer,
     order: orderSigner,
     guard: guardAddress,
     tokenInMint: tokenInMint,
@@ -127,23 +125,12 @@ export async function getSolanaSingleChainOrderInstructions(
   });
 
   instructions.push(createSingleChainLimitOrderIx);
-  const tip = resolveSolanaTip(options);
-
-  if (tip) {
-    instructions.push(
-      getTransferSolInstruction({
-        source: feePayerSigner,
-        destination: tip.account,
-        amount: tip.lamports,
-      }),
-    );
-  }
 
   const { value: latestBlockhash } = await rpc.getLatestBlockhash({ commitment: 'confirmed' }).send();
 
   const txMessage = pipe(
     createTransactionMessage({ version: 0 }),
-    (tx) => setTransactionMessageFeePayerSigner(feePayerSigner, tx),
+    (tx) => setTransactionMessageFeePayerSigner(signer, tx),
     (tx) => setTransactionMessageLifetimeUsingBlockhash(latestBlockhash, tx),
     (tx) => appendTransactionMessageInstructions(instructions, tx),
     (tx) => addSignersToTransactionMessage([orderSigner], tx),
@@ -162,12 +149,11 @@ export async function getSolanaSingleChainOrderInstructions(
 
 export async function getSolanaCrossChainOrderInstructions(
   order: CrossChainOrder,
-  options?: SolanaTransactionOptions,
+  options?: { rpcUrl?: string },
 ): Promise<SolanaOrderInstructionResult> {
   const rpc = options?.rpcUrl ? createSolanaRpc(options.rpcUrl) : getDefaultSolanaRPC();
   const orderSigner = await generateKeyPairSigner();
-  const userSigner = createNoopSigner(order.user as Address);
-  const feePayerSigner = resolveSolanaFeePayer(userSigner, options?.feePayer);
+  const signer = createNoopSigner(order.user as Address);
 
   let tokenInMint = address(order.sourceTokenAddress);
 
@@ -214,7 +200,7 @@ export async function getSolanaCrossChainOrderInstructions(
 
     if (!userTokenInAccount.exists) {
       const createAccountIx = await getCreateAssociatedTokenInstructionAsync({
-        payer: feePayerSigner,
+        payer: signer,
         ata: tokenInProgramAccount,
         owner: orderUserAddress,
         mint: tokenMintProgram.address,
@@ -225,7 +211,7 @@ export async function getSolanaCrossChainOrderInstructions(
     }
 
     const transferIx = getTransferSolInstruction({
-      source: userSigner,
+      source: signer,
       destination: userTokenInAccount.address,
       amount: order.sourceTokenAmount,
     });
@@ -241,7 +227,7 @@ export async function getSolanaCrossChainOrderInstructions(
   const executionHashUint8Array = order.executionDetailsHashToBytes();
 
   const createOrderIx = getCreateOrderInstruction({
-    user: userSigner,
+    user: signer,
     order: orderSigner,
     guard: address(CROSS_CHAIN_GUARD_ADDRESSES[ChainID.Solana]),
     systemProgram: SYSTEM_PROGRAM_ADDRESS,
@@ -257,23 +243,12 @@ export async function getSolanaCrossChainOrderInstructions(
   });
 
   instructions.push(createOrderIx);
-  const tip = resolveSolanaTip(options);
-
-  if (tip) {
-    instructions.push(
-      getTransferSolInstruction({
-        source: feePayerSigner,
-        destination: tip.account,
-        amount: tip.lamports,
-      }),
-    );
-  }
 
   const { value: latestBlockhash } = await rpc.getLatestBlockhash({ commitment: 'confirmed' }).send();
 
   const txMessage = pipe(
     createTransactionMessage({ version: 0 }),
-    (tx) => setTransactionMessageFeePayerSigner(feePayerSigner, tx),
+    (tx) => setTransactionMessageFeePayerSigner(signer, tx),
     (tx) => setTransactionMessageLifetimeUsingBlockhash(latestBlockhash, tx),
     (tx) => appendTransactionMessageInstructions(instructions, tx),
     (tx) => addSignersToTransactionMessage([orderSigner], tx),

package/src/core/sui/intent-helpers.ts

@@ -84,6 +84,8 @@ export function createSuiSingleChainLimitOrderIntentRequest(
     deadline: params.deadline,
 
     takeProfitMinOut: params.takeProfitMinOut,
+    stopLossType: params.stopLossType,
+    stopLossTriggerPrice: params.stopLossTriggerPrice,
   } as SingleChainOrder;
 
   return {
@@ -153,7 +155,8 @@ export function createSuiCrossChainOrderIntentRequest(
   };
   const executionDetailsString = JSON.stringify(executionDetails, Parsers.bigIntReplacer);
 
-  const executionDetailsHash = generateExecutionDetailsHash(executionDetails);
+  // Hash the exact string we send; the auctioneer recomputes sha256 over it and rejects on mismatch
+  const executionDetailsHash = generateExecutionDetailsHash(executionDetailsString);
 
   const genericData = {
     user: params.user,

package/src/index.ts

@@ -11,6 +11,7 @@ export { CrossChainOrder } from './core/orders/cross-chain.js';
 export type { CreateCrossChainOrderParams } from './core/orders/cross-chain.js';
 export { SingleChainOrder } from './core/orders/single-chain.js';
 export type { CreateSingleChainOrderParams } from './core/orders/single-chain.js';
+export type { StopLossType } from './core/orders/common.js';
 
 export { fetchUserOrders } from './core/orders/api/fetch.js';
 export { AuctioneerAPI } from './core/orders/api/index.js';
@@ -28,12 +29,6 @@ export {
 } from './types/api.js';
 export { calculateAmounts, getCoinFromResponse, getTokensData } from './utils/defillama.js';
 export type { DefiLlamaCoinData, DefiLlamaTokensResponse } from './utils/defillama.js';
-export {
-  DEV_ACCESS_HEADER,
-  DEV_ACCESS_STORAGE_KEY,
-  getDevAccessHeaderValue,
-  withAuctioneerHeaders,
-} from './utils/auctioneer-headers.js';
 export {
   getCancelCrossChainOrderRawData,
   getCancelSingleChainOrderRawData,
@@ -51,7 +46,6 @@ export {
   getSolanaSingleChainOrderInstructions,
   type SolanaOrderInstructionResult,
 } from './core/solana/order-instructions.js';
-export { type SolanaTransactionOptions } from './core/solana/transaction-options.js';
 export {
   cancelCrossChainOrderInstructionsAsBytes,
   cancelSingleChainOrderInstructionsAsBytes,
@@ -99,13 +93,16 @@ export {
   createEvmSingleChainLimitOrderIntentRequest,
   createEvmSingleChainDcaOrderIntentRequest,
   createEvmCrossChainOrderIntentRequest,
+  createEvmCrossChainDcaOrderIntentRequest,
   generateEvmSingleChainLimitOrderTypedData,
   generateEvmSingleChainDcaOrderTypedData,
   generateEvmCrossChainOrderTypedData,
+  getEVMCrossChainDcaOrderTypedData,
   generateEvmRandomNonce,
   type CreateEvmSingleChainLimitOrderIntentParams,
   type CreateEvmSingleChainDcaOrderIntentParams,
   type CreateEvmCrossChainOrderIntentParams,
+  type CreateEvmCrossChainDcaOrderIntentParams,
 } from './core/evm/intent-helpers.js';
 
 // Solana Intent Helpers

package/src/types/api.ts

@@ -1,6 +1,13 @@
 import type { ExtraTransfer } from '../core/orders/common.js';
 
-export type ChainOrderStatus = 'Auction' | 'NoBids' | 'Executing' | 'Fulfilled' | 'Cancelled' | 'Outdated';
+export type ChainOrderStatus =
+  | 'Auction'
+  | 'NoBids'
+  | 'Executing'
+  | 'Fulfilled'
+  | 'Cancelled'
+  | 'Outdated'
+  | 'DcaIntervalFulfilled';
 
 export type ApiCrossChainOrder = {
   orderId: string;
@@ -61,8 +68,12 @@ export interface ApiIntentResponse {
   /** Unique identifier for the created intent */
   intentId: string;
 
-  /** JWT token used for authorization or subsequent requests */
-  jwt: string;
+  /**
+   * JWT token used for authorization or subsequent requests.
+   * Optional: order-creation responses only return `intentId`; obtain a JWT via the
+   * SIWE flow (`EVMSDK.authenticate()` / `fetchJWTToken`) instead.
+   */
+  jwt?: string;
 }
 export type ValidResponseData = ApiUserOrders | string | ApiIntentResponse | null;
 

package/src/types/intent.ts

@@ -1,6 +1,6 @@
 import type { SupportedChain } from '../chains.js';
 import type { CrossChainOrder } from '../core/orders/cross-chain.js';
-import type { ExtraTransfer } from '../core/orders/common.js';
+import type { ExtraTransfer, StopLossType } from '../core/orders/common.js';
 import type { SingleChainOrder } from '../core/orders/single-chain.js';
 import type { DcaSingleChainOrder } from '../core/orders/dca-single-chain.js';
 
@@ -20,7 +20,11 @@ export type ExecutionDetails = {
   /** Extra transfers to be made */
   extraTransfers?: ExtraTransfer[];
 
-  stopLossMaxOut?: bigint;
+  /** Stop loss type, must match the auctioneer's `stopLossType` field */
+  stopLossType?: StopLossType;
+  /** Initial trigger price (tokenIn/tokenOut) that arms the stop loss */
+  stopLossTriggerPrice?: string;
+  /** Take profit minimum amount out */
   takeProfitMinOut?: bigint;
 };
 
@@ -96,6 +100,36 @@ export type SingleChainUserIntentRequest = {
   };
 };
 
+/**
+ * Source chain data for a cross-chain DCA order. Mirrors the auctioneer's
+ * `CrossChainDcaOrderGenericRequestData` (common cross-chain fields + flattened
+ * `CommonDcaOrderData`). The destination fields live in `executionDetails`.
+ */
+export type DcaCrossChainSourceChainData = {
+  user: string;
+  srcChainId: SupportedChain;
+  tokenIn: string;
+  minStablecoinsAmount: bigint;
+  deadline: number;
+  executionDetailsHash: ExecutionDetailsHash;
+  /** Flattened CommonDcaOrderData */
+  startTime: number;
+  amountInPerInterval: bigint;
+  totalIntervals: number;
+  intervalDuration: number;
+};
+
+export type DcaCrossChainUserIntentRequest = {
+  genericData: DcaCrossChainSourceChainData;
+  /** JSON-stringified execution details for the destination chain */
+  executionDetails: string;
+  chainSpecificData: {
+    EVM?: DcaSingleChainEVMPreparedData;
+    Solana?: DcaSingleChainSolanaPreparedData;
+    Sui?: DcaSingleChainSuiPreparedData;
+  };
+};
+
 export type ChainPreparedData = EvmPreparedData | SuiPreparedData | SolanaPreparedData;
 
 export type CrossChainOrderPrepared = {

package/src/utils/base-validator.ts

@@ -32,10 +32,6 @@ export abstract class BaseValidator implements IChainValidator {
     this.validateAmount(order.amountIn);
     this.validateAmount(order.amountOutMin ?? 1n);
 
-    if (order.stopLossMaxOut) {
-      this.validateAmount(order.stopLossMaxOut);
-    }
-
     if (order.takeProfitMinOut) {
       this.validateAmount(order.takeProfitMinOut);
     }

package/src/utils/generate-execution-details-hash.ts

@@ -1,36 +1,13 @@
 import { createHash } from 'crypto';
-import type { ExtraTransfer } from '../core/orders/common.js';
-import { Parsers } from './parsers.js';
-
-export function generateExecutionDetailsHash({
-  destChainId,
-  destinationAddress,
-  tokenOut,
-  amountOutMin,
-  stopLossMaxOut,
-  takeProfitMinOut,
-  extraTransfers,
-}: {
-  destChainId: number;
-  destinationAddress: string;
-  tokenOut: string;
-  amountOutMin: string;
-  stopLossMaxOut?: string;
-  takeProfitMinOut?: string;
-  extraTransfers?: ExtraTransfer[];
-}): string {
-  const executionDetails = JSON.stringify(
-    {
-      destChainId,
-      destinationAddress,
-      tokenOut,
-      amountOutMin,
-      stopLossMaxOut,
-      takeProfitMinOut,
-      extraTransfers,
-    },
-    Parsers.bigIntReplacer,
-  );
 
+/**
+ * Computes the SHA-256 hash the auctioneer expects for cross-chain execution details.
+ *
+ * The auctioneer recomputes sha256 over the exact `executionDetails` JSON string it
+ * receives and rejects the order when it differs (hash mismatch). Callers therefore MUST
+ * hash the same serialized string they send on the wire — pass that string here directly
+ * instead of re-serializing a parallel object, which is how key-order/field drift creeps in.
+ */
+export function generateExecutionDetailsHash(executionDetails: string): string {
   return '0x' + createHash('sha256').update(executionDetails).digest('hex');
 }

package/src/utils/quote/address.ts

@@ -0,0 +1,4 @@
+/** Case-insensitive address equality; false if either address is missing. */
+export function compareAddresses(firstAddress?: string, secondAddress?: string): boolean {
+  return !!firstAddress && !!secondAddress && firstAddress.toLowerCase() === secondAddress.toLowerCase();
+}

package/src/utils/quote/aggregator.ts

@@ -9,10 +9,11 @@ import { LiquidSwapQuoteProvider, type LiquidSwapQuoteResponse } from './liquids
 import { RaydiumQuoteProvider, type RaydiumPumpQuoteParams, type RaydiumQuoteResponse } from './raydium.js';
 import { PumpFunQuoteProvider } from './pumpfun/index.js';
 import { RelayQuoteProvider } from './relay.js';
-
-const compareAddresses = (firstAddress?: string, secondAddress?: string): boolean => {
-  return !!firstAddress && !!secondAddress && firstAddress.toLowerCase() === secondAddress.toLowerCase();
-};
+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 { compareAddresses } from './address.js';
 
 type SingleChainQuoteParams = {
   chainId: ChainID;
@@ -95,6 +96,7 @@ export class QuoteProvider {
         },
       };
     } 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');
     }
@@ -136,12 +138,22 @@ export class QuoteProvider {
       tokenOut: sourceStable.address,
     };
 
-    const sourceQuote = await this.getSingleChainQuote(sourceSingleChainQuoteParams);
+    const [sourceQuote, expenses] = await Promise.all([
+      this.getSingleChainQuote(sourceSingleChainQuoteParams),
+      estimateExpensesInTokenOut({
+        chainId: params.destChainId,
+        tokenOut: params.tokenOut,
+        gasLimit: EVM_CROSS_CHAIN_GAS_LIMIT,
+        getQuote: (p) => this.getSingleChainQuote(p),
+      }),
+    ]);
 
     // Step 2: Normalize stable amount between source and destination ---
     // Adjust for decimal difference between stables (e.g. 6 → 18)
-    const normalizedBridgeAmount = BigInt(
-      Math.floor((Number(sourceQuote.amountOut) / 10 ** sourceStable.decimals) * 10 ** destStable.decimals),
+    const normalizedBridgeAmount = convertDecimals(
+      sourceQuote.amountOut,
+      sourceStable.decimals,
+      destStable.decimals,
     );
 
     // Step 3: Get quote from dest bridge stable → target token ---
@@ -154,17 +166,25 @@ export class QuoteProvider {
 
     const destQuote = await this.getSingleChainQuote(destSingleChainQuoteParams);
 
-    // -Step 4: Compute stable min-amount with correct decimals ---
+    // Step 4: Compute stable min-amount with correct decimals ---
     const estimatedAmountInAsMinStablecoinAmount = BigInt(
       Math.floor(sourceQuote.amountInUsd * 10 ** sourceStable.decimals),
     );
 
+    const swapOutput = destQuote.amountOutMin ?? destQuote.amountOut;
+    const estimatedAmountOutReduced = estimateAmountOut(
+      swapOutput,
+      DEFAULT_COMMISSION_BPS,
+      expenses,
+      CROSS_CHAIN_COMMISSION_DENOMINATOR,
+    );
+
     return {
       estimatedAmountOut: destQuote.amountOut,
       estimatedAmountOutUsd: destQuote.amountOutUsd,
       amountInUsd: sourceQuote.amountInUsd,
       estimatedAmountInAsMinStablecoinAmount,
-      estimatedAmountOutReduced: destQuote.amountOutMin || destQuote.amountOut,
+      estimatedAmountOutReduced,
       estimatedAmountOutUsdReduced: destQuote.amountOutUsd,
     };
   }

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

@@ -0,0 +1,33 @@
+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
+
+/** Single-chain divisor — mirrors evaluate.rs:130-131 (`commission / 10_000`). */
+export const SINGLE_CHAIN_COMMISSION_DENOMINATOR = 10_000n;
+
+/**
+ * Cross-chain divisor — mirrors cross_chain_estimation.rs:213-214 (`commission / 100_000`).
+ * The asymmetry with the single-chain divisor is intentional (verbatim solver mirror);
+ * confirm with the solver team whether this is a unit choice or a bug before relying on it.
+ */
+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). */
+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).
+ */
+export const NON_EVM_FIXED_NATIVE_GAS_COST: Partial<Record<ChainID, bigint>> = {
+  [ChainID.Sui]: 20_000_000n,
+  [ChainID.Solana]: 200_000n,
+};

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

@@ -0,0 +1,11 @@
+/**
+ * Integer decimal conversion between two tokens, mirroring solver cross_chain_estimation.rs:205-211.
+ * Uses BigInt powers of ten to avoid the float precision loss of `Math.floor(Number(...))`.
+ */
+export function convertDecimals(amount: bigint, fromDecimals: number, toDecimals: number): bigint {
+  const diff = toDecimals - fromDecimals;
+  if (diff >= 0) {
+    return amount * 10n ** BigInt(diff);
+  }
+  return amount / 10n ** BigInt(-diff);
+}

package/src/utils/quote/pricing/estimate-amount-out.ts

@@ -0,0 +1,36 @@
+/** Expense components, all expressed in the output token's smallest units. */
+export type Expenses = {
+  gasInTokenOut: bigint;
+  protocolFeeInTokenOut: bigint;
+  extraTransfersInTokenOut: bigint;
+};
+
+/** Thrown when total expenses meet or exceed the swap output, mirroring the solver's rejection. */
+export class IntentNotViableError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = 'IntentNotViableError';
+  }
+}
+
+/**
+ * Ports solver_rust evaluate.rs: final amount = swapOutput − expenses − commission.
+ * `commissionBps` is basis points; `commissionDenominator` selects single-chain (10_000n)
+ * vs cross-chain (100_000n) semantics. Throws IntentNotViableError when nothing is left.
+ */
+export function estimateAmountOut(
+  swapOutput: bigint,
+  commissionBps: bigint,
+  expenses: Expenses,
+  commissionDenominator = 10_000n,
+): bigint {
+  const commissionFee = (swapOutput * commissionBps) / commissionDenominator;
+  const total =
+    expenses.gasInTokenOut + expenses.protocolFeeInTokenOut + expenses.extraTransfersInTokenOut + commissionFee;
+
+  if (total >= swapOutput) {
+    throw new IntentNotViableError(`Total expenses (${total}) meet or exceed swap output (${swapOutput})`);
+  }
+
+  return swapOutput - total;
+}