@shogun-sdk/intents-sdk 1.4.1 → 1.4.3

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,
+  };
 }

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

@@ -1,23 +1,88 @@
 import { getGasPrice } from 'viem/actions';
-import { isEvmChain, type SupportedChain } from '../../../chains.js';
+import { ChainID, isEvmChain, type SupportedChain } from '../../../chains.js';
 import { ChainProvider } from '../../../core/evm/chain-provider.js';
-import { NON_EVM_FIXED_NATIVE_GAS_COST } from './constants.js';
+import {
+  EVM_CROSS_CHAIN_GAS_LIMIT,
+  EVM_CROSS_CHAIN_SOURCE_GAS_LIMIT,
+  EVM_CROSS_CHAIN_SOURCE_NO_SWAP_GAS_LIMIT,
+  EVM_SINGLE_CHAIN_GAS_LIMIT,
+  GAS_PRICE_SAFETY_MARGIN_BPS,
+  NON_EVM_FIXED_NATIVE_GAS_COST,
+  SOLANA_BASE_TX_COST,
+  SOLANA_CLAIM_TOKENS_COST,
+  SOLANA_CREATE_ATA_COST,
+  SOLANA_CREATE_EMPTY_ACC_COST,
+  SOLANA_JITO_TIP,
+  SOLANA_START_WITHOUT_SWAP_COST,
+} from './constants.js';
+
+/**
+ * Which solver execution the gas estimate models. crossChainSourceNoSwap is the source
+ * leg when token_in needs no swap into the stablecoin (start_order_execution_without_swap).
+ */
+export type GasFlow = 'singleChain' | 'crossChainSource' | 'crossChainSourceNoSwap' | 'crossChainDest';
+
+/** EVM gas units per execution flow — pairs each flow with its solver gas limit in one place. */
+const EVM_GAS_LIMIT_BY_FLOW: Record<GasFlow, bigint> = {
+  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,
+};
+
+/** Pads the execution-price component of gas (fees/tips), never rent-exempt deposits. */
+function padGasPrice(amount: bigint): bigint {
+  return (amount * (10_000n + GAS_PRICE_SAFETY_MARGIN_BPS)) / 10_000n;
+}
+
+/**
+ * Mirrors solver chains.rs Solana branches with gas_price = 1 (the solver's unwrap_or default).
+ * ATA creation scales with payout receivers; cross-chain adds the escrow PDA / claim legs.
+ * Only the transaction/tip component takes the safety margin — rent-exempt account
+ * creation (ATA, escrow PDA) is runtime-fixed and cannot drift.
+ */
+function solanaNativeGasCost(flow: GasFlow, uniqueReceivers: number): bigint {
+  switch (flow) {
+    case 'crossChainSource':
+      // start_order_execution_with_swap_cost + claim_tokens_cost (receivers do not apply)
+      return padGasPrice(SOLANA_BASE_TX_COST + SOLANA_JITO_TIP + SOLANA_CLAIM_TOKENS_COST);
+    case 'crossChainSourceNoSwap':
+      // start_order_execution_without_swap_cost + claim_tokens_cost
+      return padGasPrice(SOLANA_START_WITHOUT_SWAP_COST + SOLANA_CLAIM_TOKENS_COST);
+    case 'crossChainDest':
+      // fulfill_cross_chain_order_cost
+      return (
+        SOLANA_CREATE_EMPTY_ACC_COST +
+        SOLANA_CREATE_ATA_COST * BigInt(uniqueReceivers) +
+        padGasPrice(SOLANA_BASE_TX_COST + SOLANA_JITO_TIP)
+      );
+    case 'singleChain':
+      // fulfill_single_chain_order_cost
+      return SOLANA_CREATE_ATA_COST * BigInt(uniqueReceivers) + padGasPrice(SOLANA_BASE_TX_COST + SOLANA_JITO_TIP);
+  }
+}
 
 /**
  * Gas cost in the chain's native smallest unit (wei / lamports / MIST).
- * EVM: live gas price × gas limit. Non-EVM: solver-mirrored fixed cost.
+ * EVM: live gas price × the flow's gas limit. Solana: solver-mirrored per-flow formula.
+ * Other non-EVM: solver-mirrored fixed cost.
  */
 export async function getNativeGasCost(params: {
   chainId: SupportedChain;
-  gasLimit: bigint;
+  flow?: GasFlow;
+  uniqueReceivers?: number;
   rpcProviderUrl?: string;
 }): Promise<bigint> {
-  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 getGasPrice(client);
-    return gasLimit * gasPrice;
+    return padGasPrice(EVM_GAS_LIMIT_BY_FLOW[flow] * gasPrice);
+  }
+
+  if (chainId === ChainID.Solana) {
+    return solanaNativeGasCost(flow, uniqueReceivers);
   }
 
   const fixed = NON_EVM_FIXED_NATIVE_GAS_COST[chainId];

package/src/utils/quote/pricing/limit-amount.ts

@@ -0,0 +1,21 @@
+import { SOLVER_DEFAULT_SLIPPAGE_BPS } from './constants.js';
+
+/**
+ * Mirrors the solver's get_limit_amount (swap_estimator_rust/src/utils/limit_amount.rs)
+ * with Slippage::Percent(DEFAULT_SLIPPAGE): the diff is `mul_div(amount, slippage, base,
+ * round_up=true)` — always rounded UP — then subtracted for ExactIn (swap outputs are
+ * worst-cased down) or added for ExactOut (expense valuations are worst-cased up).
+ */
+function slippageDiff(amountQuote: bigint): bigint {
+  return (amountQuote * SOLVER_DEFAULT_SLIPPAGE_BPS + 9_999n) / 10_000n;
+}
+
+/** Swap output the solver actually credits: `amount_limit`, not the nominal quote. */
+export function exactInLimitAmount(amountQuote: bigint): bigint {
+  return amountQuote - slippageDiff(amountQuote);
+}
+
+/** Expense valuation the solver actually charges: quote plus the rounded-up slippage diff. */
+export function exactOutLimitAmount(amountQuote: bigint): bigint {
+  return amountQuote + slippageDiff(amountQuote);
+}

package/src/utils/quote/raydium.ts

@@ -10,6 +10,7 @@ import {
   type LaunchpadPoolInfo,
 } from '@raydium-io/raydium-sdk-v2';
 import { type SimpleQuote } from './aggregator.js';
+import { compareAddresses } from './address.js';
 import { Connection, clusterApiUrl, PublicKey } from '@solana/web3.js'; // Used this package for raydium-sdk-v2 compatibility
 import BN from 'bn.js';
 import { Decimal } from 'decimal.js';
@@ -51,10 +52,6 @@ const platformConfigCache = new Map<
 
 const mintInfoCache = new Map<string, Awaited<ReturnType<Raydium['token']['getTokenInfo']>>>();
 
-// Local implementation of compareAddresses function
-const compareAddresses = (firstAddress?: string, secondAddress?: string): boolean => {
-  return !!firstAddress && !!secondAddress && firstAddress.toLowerCase() === secondAddress.toLowerCase();
-};
 
 const LAUNCHPAD_WHITELISTED_QUOTE_TOKENS = [
   new PublicKey('So11111111111111111111111111111111111111112'), // WSOL