@shogun-sdk/intents-sdk 1.4.2 → 1.4.3

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