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

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

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

@@ -0,0 +1,62 @@
+import { ChainID, type SupportedChain } from '../../../chains.js';
+import {
+  NATIVE_EVM_ETH_ADDRESSES,
+  NATIVE_SOLANA_TOKEN_ADDRESS,
+  NATIVE_SUI_TOKEN_ADDRESS,
+  isNativeEvmToken,
+} from '../../../constants.js';
+import { compareAddresses } from '../address.js';
+import type { Expenses } from './estimate-amount-out.js';
+import { getNativeGasCost } from './gas.js';
+
+/** Quotes a native->tokenOut swap on the given chain. Injected to keep this module a leaf (no dependency on the aggregator). */
+type GasQuoteFn = (params: {
+  chainId: SupportedChain;
+  amount: bigint;
+  tokenIn: string;
+  tokenOut: string;
+}) => Promise<{ amountOut: bigint }>;
+
+function nativeTokenAddressForChain(chainId: SupportedChain): string {
+  if (chainId === ChainID.Solana) return NATIVE_SOLANA_TOKEN_ADDRESS;
+  if (chainId === ChainID.Sui) return NATIVE_SUI_TOKEN_ADDRESS;
+  // EVM native sentinel addresses share the same 0xEee... value; use the first.
+  // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+  return NATIVE_EVM_ETH_ADDRESSES[0]!;
+}
+
+function isNativeToken(chainId: SupportedChain, address: string): boolean {
+  if (chainId === ChainID.Solana) return compareAddresses(address, NATIVE_SOLANA_TOKEN_ADDRESS);
+  if (chainId === ChainID.Sui) return compareAddresses(address, NATIVE_SUI_TOKEN_ADDRESS);
+  return isNativeEvmToken(address);
+}
+
+/**
+ * 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.
+ */
+export async function estimateExpensesInTokenOut(params: {
+  chainId: SupportedChain;
+  tokenOut: string;
+  gasLimit: bigint;
+  getQuote: GasQuoteFn;
+  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 };
+}

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

@@ -0,0 +1,28 @@
+import { getGasPrice } from 'viem/actions';
+import { isEvmChain, type SupportedChain } from '../../../chains.js';
+import { ChainProvider } from '../../../core/evm/chain-provider.js';
+import { NON_EVM_FIXED_NATIVE_GAS_COST } from './constants.js';
+
+/**
+ * Gas cost in the chain's native smallest unit (wei / lamports / MIST).
+ * EVM: live gas price × gas limit. Non-EVM: solver-mirrored fixed cost.
+ */
+export async function getNativeGasCost(params: {
+  chainId: SupportedChain;
+  gasLimit: bigint;
+  rpcProviderUrl?: string;
+}): Promise<bigint> {
+  const { chainId, gasLimit, rpcProviderUrl } = params;
+
+  if (isEvmChain(chainId)) {
+    const client = ChainProvider.getClient(chainId, rpcProviderUrl);
+    const gasPrice = await getGasPrice(client);
+    return gasLimit * gasPrice;
+  }
+
+  const fixed = NON_EVM_FIXED_NATIVE_GAS_COST[chainId];
+  if (fixed === undefined) {
+    throw new Error(`No fixed native gas cost configured for chain ${chainId}`);
+  }
+  return fixed;
+}