@shogun-sdk/intents-sdk 1.4.1 → 1.4.3

package/dist/index.cjs

@@ -399,6 +399,7 @@ __export(index_exports, {
   EVMSDK: () => EVMSDK,
   EVM_ZERO_ADDRESS: () => EVM_ZERO_ADDRESS,
   EVM_ZERO_SIGNATURE: () => EVM_ZERO_SIGNATURE,
+  IntentNotViableError: () => IntentNotViableError,
   IntentsOrderType: () => IntentsOrderType,
   MAX_UINT_128: () => MAX_UINT_128,
   MAX_UINT_256: () => MAX_UINT_256,
@@ -4790,6 +4791,9 @@ var ParaswapQuoteProvider = class {
   }
   async getQuote(paraswapParams) {
     const params = { ...paraswapParams };
+    if (isNativeEvmToken(params.srcToken)) {
+      params.srcToken = WRAPPED_ETH_ADDRESSES[this.chainId];
+    }
     if (isNativeEvmToken(params.destToken)) {
       params.destToken = WRAPPED_ETH_ADDRESSES[this.chainId];
     }
@@ -4919,6 +4923,13 @@ var LiquidSwapQuoteProvider = class {
 // src/utils/quote/raydium.ts
 init_constants();
 var import_raydium_sdk_v2 = require("@raydium-io/raydium-sdk-v2");
+
+// src/utils/quote/address.ts
+function compareAddresses(firstAddress, secondAddress) {
+  return !!firstAddress && !!secondAddress && firstAddress.toLowerCase() === secondAddress.toLowerCase();
+}
+
+// src/utils/quote/raydium.ts
 var import_web32 = require("@solana/web3.js");
 var import_bn2 = __toESM(require("bn.js"), 1);
 var import_decimal = require("decimal.js");
@@ -4937,9 +4948,6 @@ var launchpadPoolCache = /* @__PURE__ */ new Map();
 var launchpadPoolInfoCache = /* @__PURE__ */ new Map();
 var platformConfigCache = /* @__PURE__ */ new Map();
 var mintInfoCache = /* @__PURE__ */ new Map();
-var compareAddresses = (firstAddress, secondAddress) => {
-  return !!firstAddress && !!secondAddress && firstAddress.toLowerCase() === secondAddress.toLowerCase();
-};
 var LAUNCHPAD_WHITELISTED_QUOTE_TOKENS = [
   new import_web32.PublicKey("So11111111111111111111111111111111111111112"),
   // WSOL
@@ -6021,33 +6029,63 @@ function estimateAmountOut(swapOutput, commissionBps, expenses, commissionDenomi
 // src/utils/quote/pricing/expenses.ts
 init_constants();
 
-// src/utils/quote/address.ts
-function compareAddresses2(firstAddress, secondAddress) {
-  return !!firstAddress && !!secondAddress && firstAddress.toLowerCase() === secondAddress.toLowerCase();
-}
-
 // src/utils/quote/pricing/gas.ts
 var import_actions = require("viem/actions");
 init_chains();
 
 // src/utils/quote/pricing/constants.ts
-var DEFAULT_COMMISSION_BPS = 50n;
+var DEFAULT_COMMISSION_BPS = 0n;
+var SOLVER_DEFAULT_SLIPPAGE_BPS = 5n;
+var DEFAULT_SINGLE_CHAIN_SLIPPAGE_BPS = 50;
+var DEFAULT_CROSS_CHAIN_SLIPPAGE_BPS = 25;
 var SINGLE_CHAIN_COMMISSION_DENOMINATOR = 10000n;
 var CROSS_CHAIN_COMMISSION_DENOMINATOR = 100000n;
 var EVM_SINGLE_CHAIN_GAS_LIMIT = 3000000n;
 var EVM_CROSS_CHAIN_GAS_LIMIT = 2000000n;
+var EVM_CROSS_CHAIN_SOURCE_GAS_LIMIT = 1220000n;
+var EVM_CROSS_CHAIN_SOURCE_NO_SWAP_GAS_LIMIT = 620000n;
+var GAS_PRICE_SAFETY_MARGIN_BPS = 2000n;
 var NON_EVM_FIXED_NATIVE_GAS_COST = {
-  [101 /* Sui */]: 20000000n,
-  [7565164 /* Solana */]: 200000n
+  [101 /* Sui */]: 20000000n
 };
+var SOLANA_CREATE_ATA_COST = 2050000n;
+var SOLANA_CREATE_EMPTY_ACC_COST = 890880n;
+var SOLANA_JITO_TIP = 500000n;
+var SOLANA_BASE_TX_COST = 200000n;
+var SOLANA_CLAIM_TOKENS_COST = 300000n;
+var SOLANA_START_WITHOUT_SWAP_COST = 300000n;
 
 // src/utils/quote/pricing/gas.ts
+var EVM_GAS_LIMIT_BY_FLOW = {
+  singleChain: EVM_SINGLE_CHAIN_GAS_LIMIT,
+  crossChainSource: EVM_CROSS_CHAIN_SOURCE_GAS_LIMIT,
+  crossChainSourceNoSwap: EVM_CROSS_CHAIN_SOURCE_NO_SWAP_GAS_LIMIT,
+  crossChainDest: EVM_CROSS_CHAIN_GAS_LIMIT
+};
+function padGasPrice(amount) {
+  return amount * (10000n + GAS_PRICE_SAFETY_MARGIN_BPS) / 10000n;
+}
+function solanaNativeGasCost(flow, uniqueReceivers) {
+  switch (flow) {
+    case "crossChainSource":
+      return padGasPrice(SOLANA_BASE_TX_COST + SOLANA_JITO_TIP + SOLANA_CLAIM_TOKENS_COST);
+    case "crossChainSourceNoSwap":
+      return padGasPrice(SOLANA_START_WITHOUT_SWAP_COST + SOLANA_CLAIM_TOKENS_COST);
+    case "crossChainDest":
+      return SOLANA_CREATE_EMPTY_ACC_COST + SOLANA_CREATE_ATA_COST * BigInt(uniqueReceivers) + padGasPrice(SOLANA_BASE_TX_COST + SOLANA_JITO_TIP);
+    case "singleChain":
+      return SOLANA_CREATE_ATA_COST * BigInt(uniqueReceivers) + padGasPrice(SOLANA_BASE_TX_COST + SOLANA_JITO_TIP);
+  }
+}
 async function getNativeGasCost(params) {
-  const { chainId, gasLimit, rpcProviderUrl } = params;
+  const { chainId, flow = "singleChain", uniqueReceivers = 1, rpcProviderUrl } = params;
   if (isEvmChain(chainId)) {
     const client = ChainProvider.getClient(chainId, rpcProviderUrl);
     const gasPrice = await (0, import_actions.getGasPrice)(client);
-    return gasLimit * gasPrice;
+    return padGasPrice(EVM_GAS_LIMIT_BY_FLOW[flow] * gasPrice);
+  }
+  if (chainId === 7565164 /* Solana */) {
+    return solanaNativeGasCost(flow, uniqueReceivers);
   }
   const fixed = NON_EVM_FIXED_NATIVE_GAS_COST[chainId];
   if (fixed === void 0) {
@@ -6056,51 +6094,142 @@ async function getNativeGasCost(params) {
   return fixed;
 }
 
+// src/utils/quote/pricing/limit-amount.ts
+function slippageDiff(amountQuote) {
+  return (amountQuote * SOLVER_DEFAULT_SLIPPAGE_BPS + 9999n) / 10000n;
+}
+function exactInLimitAmount(amountQuote) {
+  return amountQuote - slippageDiff(amountQuote);
+}
+function exactOutLimitAmount(amountQuote) {
+  return amountQuote + slippageDiff(amountQuote);
+}
+
 // src/utils/quote/pricing/expenses.ts
 function nativeTokenAddressForChain(chainId) {
   if (chainId === 7565164 /* Solana */) return NATIVE_SOLANA_TOKEN_ADDRESS;
   if (chainId === 101 /* Sui */) return NATIVE_SUI_TOKEN_ADDRESS;
   return NATIVE_EVM_ETH_ADDRESSES[0];
 }
-function isNativeToken(chainId, address9) {
-  if (chainId === 7565164 /* Solana */) return compareAddresses2(address9, NATIVE_SOLANA_TOKEN_ADDRESS);
-  if (chainId === 101 /* Sui */) return compareAddresses2(address9, NATIVE_SUI_TOKEN_ADDRESS);
-  return isNativeEvmToken(address9);
+function isNativeOrWrappedNative(chainId, address9) {
+  if (chainId === 7565164 /* Solana */) {
+    return compareAddresses(address9, NATIVE_SOLANA_TOKEN_ADDRESS) || compareAddresses(address9, WRAPPED_SOL_MINT_ADDRESS);
+  }
+  if (chainId === 101 /* Sui */) return compareAddresses(address9, NATIVE_SUI_TOKEN_ADDRESS);
+  return isNativeEvmToken(address9) || compareAddresses(address9, WRAPPED_ETH_ADDRESSES[chainId]);
 }
 async function estimateExpensesInTokenOut(params) {
-  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) => padDirectAmounts ? exactOutLimitAmount(amount) : amount;
+  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)
+      )
+    )
+  );
+  extraTransfersPromise.catch(() => {
+  });
+  const uniqueReceivers = 1 + (extraTransfers?.length ?? 0);
+  const nativeGasCost = await getNativeGasCost({ chainId, flow, uniqueReceivers, rpcProviderUrl });
+  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
+  };
 }
 
 // src/utils/quote/aggregator.ts
 var QuoteProvider = 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.
+   */
   static async getQuote(params) {
     try {
-      const quote = await this.getQuoteFromRouters(params);
-      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.
+   */
+  static async getCrossChainNetQuote(params) {
+    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. */
+  static adaptQuoteResponse(quote, params) {
+    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.
+   */
+  static async getGrossQuoteFromRouters(params) {
+    const sourceStable = getStableForChain(params.sourceChainId);
+    const destStable = getStableForChain(params.destChainId);
+    const sourceQuote = await this.getSingleChainQuote({
+      chainId: params.sourceChainId,
+      amount: params.amount,
+      tokenIn: params.tokenIn,
+      tokenOut: sourceStable.address,
+      slippageBps: params.slippageBps
+    });
+    const normalizedBridgeAmount = convertDecimals(sourceQuote.amountOut, sourceStable.decimals, destStable.decimals);
+    const destQuote = await this.getSingleChainQuote({
+      chainId: params.destChainId,
+      amount: normalizedBridgeAmount,
+      tokenIn: destStable.address,
+      tokenOut: params.tokenOut,
+      slippageBps: params.slippageBps
+    });
+    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
@@ -6117,46 +6246,56 @@ var QuoteProvider = class _QuoteProvider {
     };
     return this.getSingleChainQuote(singleChainParams);
   }
-  static async getQuoteFromRouters(params) {
+  static async getNetQuoteFromRouters(params) {
     const sourceStable = getStableForChain(params.sourceChainId);
     const destStable = getStableForChain(params.destChainId);
-    const sourceSingleChainQuoteParams = {
-      chainId: params.sourceChainId,
-      amount: params.amount,
-      tokenIn: params.tokenIn,
-      tokenOut: sourceStable.address
-    };
-    const [sourceQuote, expenses] = await Promise.all([
-      this.getSingleChainQuote(sourceSingleChainQuoteParams),
+    const getQuote = (p) => this.getSingleChainQuote(p);
+    const sourceIsStable = compareAddresses(params.tokenIn, sourceStable.address);
+    const destIsStable = compareAddresses(params.tokenOut, destStable.address);
+    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"
       })
     ]);
-    const normalizedBridgeAmount = convertDecimals(
-      sourceQuote.amountOut,
-      sourceStable.decimals,
-      destStable.decimals
-    );
-    const destSingleChainQuoteParams = {
-      chainId: params.destChainId,
-      amount: normalizedBridgeAmount,
-      tokenIn: destStable.address,
-      tokenOut: params.tokenOut
-    };
-    const destQuote = await this.getSingleChainQuote(destSingleChainQuoteParams);
-    const estimatedAmountInAsMinStablecoinAmount = BigInt(
-      Math.floor(sourceQuote.amountInUsd * 10 ** sourceStable.decimals)
-    );
-    const swapOutput = destQuote.amountOutMin ?? destQuote.amountOut;
-    const estimatedAmountOutReduced = estimateAmountOut(
-      swapOutput,
+    const sourceStableOut = sourceIsStable ? sourceQuote.amountOut : exactInLimitAmount(sourceQuote.amountOut);
+    const sourceStableAfterGas = estimateAmountOut(sourceStableOut, 0n, sourceExpenses);
+    const normalizedBridgeAmount = convertDecimals(sourceStableAfterGas, sourceStable.decimals, destStable.decimals);
+    const bridgedNet = estimateAmountOut(
+      normalizedBridgeAmount,
       DEFAULT_COMMISSION_BPS,
-      expenses,
+      destExpenses,
       CROSS_CHAIN_COMMISSION_DENOMINATOR
     );
+    const destQuote = await this.getSingleChainQuote({
+      chainId: params.destChainId,
+      amount: bridgedNet,
+      tokenIn: destStable.address,
+      tokenOut: params.tokenOut,
+      slippageBps: params.slippageBps ?? DEFAULT_CROSS_CHAIN_SLIPPAGE_BPS
+    });
+    const estimatedAmountInAsMinStablecoinAmount = sourceStableOut;
+    const estimatedAmountOutReduced = destIsStable ? destQuote.amountOut : exactInLimitAmount(destQuote.amountOut);
     return {
       estimatedAmountOut: destQuote.amountOut,
       estimatedAmountOutUsd: destQuote.amountOutUsd,
@@ -6167,12 +6306,12 @@ var QuoteProvider = class _QuoteProvider {
     };
   }
   static async getSingleChainQuote(params) {
-    if (compareAddresses2(params.tokenIn, params.tokenOut)) {
+    if (compareAddresses(params.tokenIn, params.tokenOut)) {
       let amountUsd = 0;
       const stable = getStableForChain(params.chainId);
       const stableAddress = stable.address;
       const stableDecimals = stable.decimals;
-      if (compareAddresses2(params.tokenIn, stableAddress)) {
+      if (compareAddresses(params.tokenIn, stableAddress)) {
         amountUsd = Number(params.amount) / 10 ** stableDecimals;
       }
       return {
@@ -6231,6 +6370,22 @@ var QuoteProvider = class _QuoteProvider {
     }
     throw new Error(`Unsupported chain for quote: ${params.chainId}`);
   }
+  static async getSingleChainNetQuote(params) {
+    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"
+      })
+    ]);
+    const swapOutput = exactInLimitAmount(quote.amountOut);
+    const netAmountOut = estimateAmountOut(swapOutput, DEFAULT_COMMISSION_BPS, expenses, SINGLE_CHAIN_COMMISSION_DENOMINATOR);
+    return { quote, netAmountOut, expenses };
+  }
   static transformLiquidSwapQuote(liquidSwapQuote) {
     return {
       amountIn: liquidSwapQuote.execution.details.amountIn,
@@ -6275,8 +6430,7 @@ var QuoteProvider = 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
     });
   }
   static async getParaswapQuote(params) {
@@ -6311,8 +6465,7 @@ var QuoteProvider = 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));
@@ -6327,8 +6480,7 @@ var QuoteProvider = 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");
   }
@@ -6341,9 +6493,9 @@ var QuoteProvider = class _QuoteProvider {
     const stableAddress = stable.address;
     const stableDecimals = stable.decimals;
     let amountUsd = 0;
-    if (compareAddresses2(request.tokenIn, stableAddress)) {
+    if (compareAddresses(request.tokenIn, stableAddress)) {
       amountUsd = Number(quote.coinIn.amount) / 10 ** stableDecimals;
-    } else if (compareAddresses2(request.tokenOut, stableAddress)) {
+    } else if (compareAddresses(request.tokenOut, stableAddress)) {
       amountUsd = Number(quote.coinOut.amount) / 10 ** stableDecimals;
     }
     return {
@@ -6412,9 +6564,9 @@ var QuoteProvider = class _QuoteProvider {
     const stableDecimals = stable.decimals;
     let amountUsd = 0;
     const priceImpact = quote.priceImpactPct ? Number(quote.priceImpactPct) * 100 : 0;
-    if (compareAddresses2(quote.outputMint, stableAddress)) {
+    if (compareAddresses(quote.outputMint, stableAddress)) {
       amountUsd = amountOut / 10 ** stableDecimals;
-    } else if (compareAddresses2(quote.inputMint, stableAddress)) {
+    } else if (compareAddresses(quote.inputMint, stableAddress)) {
       amountUsd = amountIn / 10 ** stableDecimals;
     }
     return {
@@ -6438,9 +6590,9 @@ var QuoteProvider = class _QuoteProvider {
     const stableDecimals = stable.decimals;
     let amountUsd = 0;
     const priceImpact = Number(raydiumQuote.data.priceImpactPct) * 100;
-    if (compareAddresses2(raydiumQuote.data.outputMint, stableAddress)) {
+    if (compareAddresses(raydiumQuote.data.outputMint, stableAddress)) {
       amountUsd = Number(amountOut) / 10 ** stableDecimals;
-    } else if (compareAddresses2(raydiumQuote.data.inputMint, stableAddress)) {
+    } else if (compareAddresses(raydiumQuote.data.inputMint, stableAddress)) {
       amountUsd = Number(amountIn) / 10 ** stableDecimals;
     }
     return {
@@ -6593,12 +6745,14 @@ var CrossChainOrder = class _CrossChainOrder {
       };
     }
     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
+        tokenOut: input.destinationTokenAddress,
+        extraTransfers: input.extraTransfers,
+        slippageBps: input.slippageBps
       });
       return {
         destinationTokenMinAmount: quote.estimatedAmountOutReduced,
@@ -6805,22 +6959,15 @@ var SingleChainOrder = 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)
-          })
-        ]);
-        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":
         return amountOutMin;