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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shogun-sdk/intents-sdk",
-  "version": "1.2.6-test.14",
+  "version": "1.2.6-test.16",
   "type": "module",
   "description": "Shogun Network Intent-based cross-chain swaps SDK",
   "author": "Shogun network",
@@ -48,7 +48,8 @@
     "@types/node": "22.13.10",
     "codama": "1.3.4",
     "tsup": "^8.5.0",
-    "typescript": "5.8.2"
+    "typescript": "5.8.2",
+    "vitest": "^2.1.9"
   },
   "dependencies": {
     "@codama/visitors-core": "^1.3.7",
@@ -89,6 +90,8 @@
     "lint": "npx eslint --fix --ext .ts ./src",
     "format": "prettier --write ./src",
     "pre-publish": "pnpm node ./scripts/prePublish.js",
-    "generate-solana-idl": "pnpm node ./scripts/codama.js"
+    "generate-solana-idl": "pnpm node ./scripts/codama.js",
+    "test": "vitest run",
+    "test:watch": "vitest"
   }
 }

package/src/auth/siwe.ts

@@ -1,5 +1,5 @@
 import type { ChainID } from '../chains.js';
-import { AUCTIONEER_URL, DEV_ACCESS_KEY } from '../constants.js';
+import { AUCTIONEER_URL } from '../constants.js';
 import type { ApiResponse } from '../types/api.js';
 
 export type FetchSiweMessageParams = {
@@ -14,13 +14,7 @@ export type FetchJWTParams = {
 
 export async function fetchSiweMessage(params: FetchSiweMessageParams) {
   const url = `${AUCTIONEER_URL}/siwe?wallet=${params.wallet}&chainId=${params.chainId}`;
-  const response = await fetch(url, {
-    headers: {
-      ...(DEV_ACCESS_KEY
-        ? { "x-dev-access": DEV_ACCESS_KEY }
-        : {})
-    }
-  });
+  const response = await fetch(url);
   if (!response.ok) {
     throw new Error(`Failed to fetch SIWE message: ${response.status} ${response.statusText}`);
   }
@@ -30,12 +24,17 @@ export async function fetchSiweMessage(params: FetchSiweMessageParams) {
 
 export async function fetchJWTToken(params: FetchJWTParams, token?: string) {
   const url = `${AUCTIONEER_URL}/siwe`;
+  const headers: Record<string, string> = { 'Content-Type': 'application/json' };
+  // Only forward an existing token when present; the server merges the newly verified
+  // wallet into it. Sending `Bearer undefined` would be a no-op the server discards.
+  if (token) {
+    headers.Authorization = `Bearer ${token}`;
+  }
+
   const response = await fetch(url, {
     method: 'POST',
     body: JSON.stringify(params),
-    headers: {
-      Authorization: `Bearer ${token}`,
-    },
+    headers,
   });
 
   if (!response.ok) {

package/src/constants.ts

@@ -79,7 +79,9 @@ export const PROD_DCA_SINGLE_CHAIN_GUARD_ADDRESSES: Record<SupportedEvmChain, Ev
   [ChainID.Arbitrum]: '0x0000000000000000000000000000000000000000' as EvmAddress,
   [ChainID.Optimism]: '0x1b754840f058b78e412156d2674b5954728cb86e' as EvmAddress,
   [ChainID.Base]: '0x2df3ab1bb8b9d48769718003de2d8ca8e9d3c465' as EvmAddress,
-  [ChainID.Hyperliquid]: '0x618ee9b6829261108d811b91581e00da192b0b75' as EvmAddress,
+  // HyperEVM SingleChainGuardDca per the on-chain deployment + auctioneer config.
+  // (0x618ee9… is the SingleChainGuardLimit, which previously sat here by mistake.)
+  [ChainID.Hyperliquid]: '0xdcbb658910b5192a43b79fd8244bdf27940d3b6b' as EvmAddress,
   [ChainID.BSC]: '0x11ef880e2e8d17c114b9eb87369ce3d1311c62e1' as EvmAddress,
   [ChainID.MONAD]: '0x418302C3bef14D405A9B30381a9cb9d4d82EB2d4' as EvmAddress,
 };
@@ -116,6 +118,10 @@ export const DCA_SINGLE_CHAIN_GUARD_ADDRESSES = useProdConfig
   ? PROD_DCA_SINGLE_CHAIN_GUARD_ADDRESSES
   : TEST_DCA_SINGLE_CHAIN_GUARD_ADDRESSES;
 
+// No separate test deployment is configured for cross-chain DCA guards yet; prod values
+// match the auctioneer's `cross_chain.guard_dca` config and are used in both modes.
+export const DCA_CROSS_CHAIN_GUARD_ADDRESSES = PROD_DCA_CROSS_CHAIN_GUARD_ADDRESSES;
+
 export const NATIVE_SOLANA_TOKEN_ADDRESS =
   'So11111111111111111111111111111111111111111' as SolanaAddress<'So11111111111111111111111111111111111111111'>;
 export const WRAPPED_SOL_MINT_ADDRESS =
@@ -145,9 +151,15 @@ export const SUI_GUARD_COLLATERAL_TYPE =
 export const SUI_GUARD_STABLECOIN_TYPE =
   '0xdba34672e30cb065b1f93e3ab55318768fd6fef66c15942c9f7cb846e2f900e7::usdc::USDC';
 
-export const AUCTIONEER_URL = useProdConfig
-  ? 'https://auctioneer-825534211396.us-central1.run.app'
-  : 'http://127.0.0.1:8080';
+// `INTENTS_AUCTIONEER_URL` overrides the default endpoint (e.g. to target a locally
+// running auctioneer) without touching the committed `useProdConfig` flag. Guarded so it
+// is a no-op in browser bundles where `process` is undefined.
+const auctioneerUrlOverride =
+  typeof process !== 'undefined' ? process.env?.INTENTS_AUCTIONEER_URL : undefined;
+
+export const AUCTIONEER_URL =
+  auctioneerUrlOverride ||
+  (useProdConfig ? 'https://auctioneer-825534211396.us-central1.run.app' : 'http://127.0.0.1:8080');
 
 export const MAX_UINT_32 = 2n ** 32n - 1n;
 export const MAX_UINT_64 = 2n ** 64n - 1n;
@@ -176,8 +188,20 @@ export function isNativeEvmToken(tokenAddress: string): boolean {
   return NATIVE_EVM_ETH_ADDRESSES.some((addr) => addr.toLowerCase() === normalizedAddress);
 }
 
-export const TOKEN_SEARCH_API_BASE_URL = 'https://shogun-token-search-api-825534211396.europe-west4.run.app';
+export const EVM_ZERO_ADDRESS = '0x0000000000000000000000000000000000000000' as EvmAddress;
 
-export const DEV_ACCESS_KEY = typeof window !== "undefined"
-  ? localStorage.getItem("x-dev-access")
-  : null;
+/** Placeholder signature (32 zero bytes) for unsigned/validate-only intent requests. */
+export const EVM_ZERO_SIGNATURE = '0x0000000000000000000000000000000000000000000000000000000000000000';
+
+/**
+ * Output-token addresses must be normalized to the zero address before signing the EIP-712
+ * witness: the auctioneer collapses any native sentinel (`0xeee…`/`0x0…`) to `Address::default()`
+ * when it reconstructs `requestedOutput`/`extraTransfers` to recover the signer. Signing the raw
+ * sentinel instead would yield a different hash → signature recovery fails. (`tokenIn` is NOT
+ * normalized on either side, so leave it untouched.)
+ */
+export function normalizeNativeEvmTokenForSigning(tokenAddress: string): string {
+  return isNativeEvmToken(tokenAddress) ? EVM_ZERO_ADDRESS : tokenAddress;
+}
+
+export const TOKEN_SEARCH_API_BASE_URL = 'https://shogun-token-search-api-825534211396.europe-west4.run.app';

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

@@ -1,8 +1,10 @@
+import type { Address, Hex, TypedDataDefinition } from 'viem';
 import type { SupportedEvmChain } from '../../chains.js';
 import type {
   SingleChainUserIntentRequest,
   CrossChainUserIntentRequest,
   DcaSingleChainUserIntentRequest,
+  DcaCrossChainUserIntentRequest,
 } from '../../types/intent.js';
 import type { SingleChainOrder } from '../orders/single-chain.js';
 import type { CrossChainOrder } from '../orders/cross-chain.js';
@@ -13,6 +15,13 @@ import {
   getEVMSingleChainOrderTypedData,
   getEVMDcaSingleChainOrderTypedData,
 } from './order-signature.js';
+import {
+  CROSS_CHAIN_DCA_PERMIT2_TYPES,
+  PERMIT2_DOMAIN,
+  type CrossChainDcaPermitTransferFrom,
+} from './permit2.js';
+import { EVMIntentProvider } from './intent-provider.js';
+import { DCA_CROSS_CHAIN_GUARD_ADDRESSES, EVM_ZERO_SIGNATURE } from '../../constants.js';
 import { generateExecutionDetailsHash } from '../../utils/generate-execution-details-hash.js';
 import { Parsers } from '../../utils/parsers.js';
 
@@ -97,7 +106,7 @@ export function createEvmSingleChainLimitOrderIntentRequest(
     chainSpecificData: {
       EVM: {
         nonce: params.nonce || String(Math.floor(Math.random() * 10000000)),
-        signature: params.signature || '0x0000000000000000000000000000000000000000000000000000000000000000',
+        signature: params.signature || EVM_ZERO_SIGNATURE,
       },
     },
   };
@@ -131,7 +140,7 @@ export function createEvmSingleChainDcaOrderIntentRequest(
     chainSpecificData: {
       EVM: {
         nonce: params.nonce || String(Math.floor(Math.random() * 10000000)),
-        signature: params.signature || '0x0000000000000000000000000000000000000000000000000000000000000000',
+        signature: params.signature || EVM_ZERO_SIGNATURE,
       },
     },
   };
@@ -157,8 +166,8 @@ export function createEvmCrossChainOrderIntentRequest(
   };
   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,
@@ -169,9 +178,6 @@ export function createEvmCrossChainOrderIntentRequest(
     deadline: params.deadline,
     executionDetailsHash: executionDetailsHash as `0x${string}`,
     extraTransfers: params.extraTransfers,
-    takeProfitMinOut: params.takeProfitMinOut,
-    stopLossType: params.stopLossType,
-    stopLossTriggerPrice: params.stopLossTriggerPrice,
   };
 
   return {
@@ -180,7 +186,7 @@ export function createEvmCrossChainOrderIntentRequest(
     chainSpecificData: {
       EVM: {
         nonce: params.nonce || String(Math.floor(Math.random() * 10000000)),
-        signature: params.signature || '0x0000000000000000000000000000000000000000000000000000000000000000',
+        signature: params.signature || EVM_ZERO_SIGNATURE,
       },
     },
   };
@@ -220,3 +226,120 @@ export async function generateEvmCrossChainOrderTypedData(order: CrossChainOrder
 export function generateEvmRandomNonce(): string {
   return String(Math.floor(Math.random() * 10000000));
 }
+
+export type CreateEvmCrossChainDcaOrderIntentParams = {
+  user: `0x${string}`;
+  sourceChainId: SupportedEvmChain;
+  sourceTokenAddress: string;
+  destinationChainId: number;
+  destinationTokenAddress: string;
+  destinationTokenMinAmount?: bigint;
+  destinationAddress: string;
+  minStablecoinAmount?: bigint;
+  deadline: number;
+  startTime: number;
+  amountInPerInterval: bigint;
+  totalIntervals: number;
+  intervalDuration: number;
+  extraTransfers?: ExtraTransfer[];
+  nonce?: string;
+  signature?: string;
+};
+
+/**
+ * Builds the cross-chain DCA execution-details string and its SHA-256 hash.
+ * Both the wire payload and the EIP-712 witness must reference the SAME string/hash, so this
+ * is the single source of truth — the auctioneer recomputes sha256 over the string it receives.
+ */
+function buildCrossChainDcaExecutionDetails(params: CreateEvmCrossChainDcaOrderIntentParams): {
+  executionDetailsString: string;
+  executionDetailsHash: string;
+} {
+  const executionDetails = {
+    destChainId: params.destinationChainId,
+    tokenOut: params.destinationTokenAddress,
+    amountOutMin: params.destinationTokenMinAmount?.toString() || '1',
+    destinationAddress: params.destinationAddress,
+    extraTransfers: params.extraTransfers,
+  };
+  const executionDetailsString = JSON.stringify(executionDetails, Parsers.bigIntReplacer);
+  return { executionDetailsString, executionDetailsHash: generateExecutionDetailsHash(executionDetailsString) };
+}
+
+/**
+ * Creates an EVM cross-chain DCA order intent request, ready to POST to
+ * `/user_intent/cross_chain/dca_order`. Pass `nonce`/`signature` from
+ * {@link getEVMCrossChainDcaOrderTypedData} for an executable order.
+ */
+export function createEvmCrossChainDcaOrderIntentRequest(
+  params: CreateEvmCrossChainDcaOrderIntentParams,
+): DcaCrossChainUserIntentRequest {
+  const { executionDetailsString, executionDetailsHash } = buildCrossChainDcaExecutionDetails(params);
+
+  return {
+    genericData: {
+      user: params.user,
+      srcChainId: params.sourceChainId,
+      tokenIn: params.sourceTokenAddress,
+      minStablecoinsAmount: params.minStablecoinAmount || 1n,
+      deadline: params.deadline,
+      executionDetailsHash: executionDetailsHash as `0x${string}`,
+      startTime: params.startTime,
+      amountInPerInterval: params.amountInPerInterval,
+      totalIntervals: params.totalIntervals,
+      intervalDuration: params.intervalDuration,
+    },
+    executionDetails: executionDetailsString,
+    chainSpecificData: {
+      EVM: {
+        nonce: params.nonce || generateEvmRandomNonce(),
+        signature: params.signature || EVM_ZERO_SIGNATURE,
+      },
+    },
+  };
+}
+
+/**
+ * Generates the EIP-712 typed data (and nonce) for a cross-chain DCA order's Permit2 witness.
+ * Sign `orderTypedData`, then pass the resulting `nonce`/`signature` into
+ * {@link createEvmCrossChainDcaOrderIntentRequest} — both share the same execution-details hash.
+ */
+export function getEVMCrossChainDcaOrderTypedData(
+  params: CreateEvmCrossChainDcaOrderIntentParams,
+  providedNonce?: bigint,
+): { orderTypedData: TypedDataDefinition; nonce: bigint } {
+  const { executionDetailsHash } = buildCrossChainDcaExecutionDetails(params);
+  const nonce = providedNonce ?? EVMIntentProvider.getRandomNonce();
+  const totalAmountIn = params.amountInPerInterval * BigInt(params.totalIntervals);
+  const spender = DCA_CROSS_CHAIN_GUARD_ADDRESSES[params.sourceChainId] as Address;
+
+  const message: CrossChainDcaPermitTransferFrom = {
+    permitted: { token: params.sourceTokenAddress as Address, amount: totalAmountIn },
+    spender,
+    nonce,
+    deadline: BigInt(params.deadline),
+    witness: {
+      user: params.user as Address,
+      tokenIn: params.sourceTokenAddress as Address,
+      srcChainId: params.sourceChainId,
+      startTime: params.startTime,
+      deadline: params.deadline,
+      totalIntervals: params.totalIntervals,
+      intervalDuration: params.intervalDuration,
+      amountInPerInterval: params.amountInPerInterval,
+      minStablecoinsAmountPerInterval: params.minStablecoinAmount || 1n,
+      executionDetailsHash: executionDetailsHash as Hex,
+      nonce,
+    },
+  };
+
+  return {
+    orderTypedData: {
+      domain: PERMIT2_DOMAIN(params.sourceChainId),
+      types: CROSS_CHAIN_DCA_PERMIT2_TYPES,
+      primaryType: 'PermitWitnessTransferFrom',
+      message,
+    },
+    nonce,
+  };
+}

package/src/core/evm/intent-provider.ts

@@ -6,6 +6,7 @@ import {
   CROSS_CHAIN_GUARD_ADDRESSES,
   MAX_UINT_32,
   DCA_SINGLE_CHAIN_GUARD_ADDRESSES,
+  normalizeNativeEvmTokenForSigning,
 } from '../../constants.js';
 import {
   getEVMCrossChainOrderTypedData,
@@ -103,14 +104,14 @@ export class EVMIntentProvider {
     const spender = SINGLE_CHAIN_GUARD_ADDRESSES[order.chainId as SupportedEvmChain] as Address;
 
     const requestedOutput: TransferData = {
-      token: order.tokenOut as Address,
+      token: normalizeNativeEvmTokenForSigning(order.tokenOut) as Address,
       receiver: order.destinationAddress as Address,
       amount: order.amountOutMin,
     };
 
     const extraTransfers: TransferData[] =
       order.extraTransfers?.map((transfer) => ({
-        token: transfer.token as Address,
+        token: normalizeNativeEvmTokenForSigning(transfer.token) as Address,
         receiver: transfer.receiver as Address,
         amount: transfer.amount,
       })) || [];
@@ -166,14 +167,14 @@ export class EVMIntentProvider {
     const spender = DCA_SINGLE_CHAIN_GUARD_ADDRESSES[order.chainId as SupportedEvmChain] as Address;
 
     const requestedOutput: TransferData = {
-      token: order.tokenOut as Address,
+      token: normalizeNativeEvmTokenForSigning(order.tokenOut) as Address,
       receiver: order.destinationAddress as Address,
       amount: BigInt(order.amountOutMin),
     };
 
     const extraTransfers: TransferData[] =
       order.extraTransfers?.map((transfer) => ({
-        token: transfer.token as Address,
+        token: normalizeNativeEvmTokenForSigning(transfer.token) as Address,
         receiver: transfer.receiver as Address,
         amount: transfer.amount,
       })) || [];

package/src/core/evm/permit2.ts

@@ -174,3 +174,39 @@ export const DCA_SINGLE_CHAIN_PERMIT2_TYPES = {
     { name: 'witness', type: 'SingleChainDcaOrder' },
   ],
 } as const;
+
+export type CrossChainDcaPermitTransferFrom = {
+  permitted: TokenPermissions;
+  spender: Address;
+  nonce: bigint;
+  deadline: bigint;
+  witness: DcaOrderInfo;
+};
+
+// Cross-chain DCA witness — mirrors the auctioneer's
+// `DcaOrderInfo(address user,address tokenIn,uint32 srcChainId,uint32 startTime,uint32 deadline,
+//  uint24 totalIntervals,uint32 intervalDuration,uint128 amountInPerInterval,
+//  uint128 minStablecoinsAmountPerInterval,bytes32 executionDetailsHash,uint256 nonce)`.
+export const CROSS_CHAIN_DCA_PERMIT2_TYPES = {
+  TokenPermissions: TOKEN_PERMISSIONS_TYPE,
+  DcaOrderInfo: [
+    { name: 'user', type: 'address' },
+    { name: 'tokenIn', type: 'address' },
+    { name: 'srcChainId', type: 'uint32' },
+    { name: 'startTime', type: 'uint32' },
+    { name: 'deadline', type: 'uint32' },
+    { name: 'totalIntervals', type: 'uint24' },
+    { name: 'intervalDuration', type: 'uint32' },
+    { name: 'amountInPerInterval', type: 'uint128' },
+    { name: 'minStablecoinsAmountPerInterval', type: 'uint128' },
+    { name: 'executionDetailsHash', type: 'bytes32' },
+    { name: 'nonce', type: 'uint256' },
+  ],
+  PermitWitnessTransferFrom: [
+    { name: 'permitted', type: 'TokenPermissions' },
+    { name: 'spender', type: 'address' },
+    { name: 'nonce', type: 'uint256' },
+    { name: 'deadline', type: 'uint256' },
+    { name: 'witness', type: 'DcaOrderInfo' },
+  ],
+} as const;

package/src/core/orders/api/fetch.ts

@@ -1,45 +1,18 @@
-import { AUCTIONEER_URL, DEV_ACCESS_KEY } from '../../../constants.js';
-import type { ApiResponse, ApiUserOrders } from '../../../types/api.js';
+import { AuctioneerAPI } from './index.js';
+import type { ApiUserOrders } from '../../../types/api.js';
 
 /**
- * Fetches user orders by any combination of wallet addresses.
- * Builds a query string with evmWallets, solanaWallets, and suiWallets.
+ * Fetches the orders owned by the wallets encoded in a SIWE-issued JWT.
+ *
+ * The auctioneer derives the queried wallets from the verified JWT claims, never from
+ * caller-supplied params — a caller can only read intents for wallets it proved control
+ * of via SIWE. Obtain the token with `EVMSDK.authenticate()` (or the `fetchSiweMessage` +
+ * `fetchJWTToken` pair) and pass it here.
  */
-export async function fetchUserOrders(
-  evmAddress?: string | null,
-  solAddress?: string | null,
-  suiAddress?: string | null
-): Promise<ApiUserOrders> {
-  const params = new URLSearchParams();
-
-  if (evmAddress) params.append('evmWallets', evmAddress);
-  if (solAddress) params.append('solanaWallets', solAddress);
-  if (suiAddress) params.append('suiWallets', suiAddress);
-
-  if ([evmAddress, solAddress, suiAddress].every((a) => !a)) {
-    throw new Error('At least one wallet address is required');
-  }
-
-  const url = `${AUCTIONEER_URL}/user_intent?${params.toString()}`;
-
-  const response = await fetch(url, {
-    method: 'GET',
-    headers: {
-      'Content-Type': 'application/json', ...(DEV_ACCESS_KEY
-        ? { "x-dev-access": DEV_ACCESS_KEY }
-        : {})
-    },
-  });
-
-  if (!response.ok) {
-    throw new Error(`Failed to fetch user orders: ${response.status} ${response.statusText}`);
-  }
-
-  const data: ApiResponse<ApiUserOrders> = await response.json();
-
-  if (!data.success) {
-    throw new Error(`Failed to fetch user orders: ${data.error}`);
+export async function fetchUserOrders(aggregatedToken: string): Promise<ApiUserOrders> {
+  if (!aggregatedToken) {
+    throw new Error('A SIWE-issued JWT is required to fetch user orders');
   }
 
-  return data.data!;
+  return new AuctioneerAPI(aggregatedToken).getUserOrders();
 }

package/src/core/orders/cross-chain.ts

@@ -200,6 +200,9 @@ export class CrossChainOrder {
       destinationAddress: this.destinationAddress,
       amountOutMin: this.destinationTokenMinAmount,
       extraTransfers: this.extraTransfers,
+      stopLossType: this.stopLossType,
+      stopLossTriggerPrice: this.stopLossTriggerPrice,
+      takeProfitMinOut: this.takeProfitMinOut,
     };
   }
 

package/src/core/orders/single-chain.ts

@@ -4,6 +4,9 @@ import type { ApiResponse } from '../../types/api.js';
 import type { SingleChainPreparedData, SingleChainUserIntentRequest } from '../../types/intent.js';
 import { SingleChainOrderValidator } from '../../utils/order-validator.js';
 import { QuoteProvider } from '../../utils/quote/aggregator.js';
+import { estimateAmountOut } from '../../utils/quote/pricing/estimate-amount-out.js';
+import { estimateExpensesInTokenOut } from '../../utils/quote/pricing/expenses.js';
+import { DEFAULT_COMMISSION_BPS, EVM_SINGLE_CHAIN_GAS_LIMIT, SINGLE_CHAIN_COMMISSION_DENOMINATOR } from '../../utils/quote/pricing/constants.js';
 import { getEVMSingleChainOrderTypedData } from '../evm/order-signature.js';
 import { BaseSDK } from '../sdk.js';
 import { getSolanaSingleChainOrderInstructions } from '../solana/order-instructions.js';
@@ -116,14 +119,24 @@ export class SingleChainOrder {
 
     switch (scenario) {
       case 'QUOTE_REQUIRED': {
-        const quote = await QuoteProvider.getSingleChainQuote({
-          tokenIn: input.tokenIn,
-          amount: input.amountIn,
-          chainId: input.chainId,
-          tokenOut: input.tokenOut,
-        });
-        // TODO: Change this. Maybe we can use token prices api and subtract gas fees (0.5$)
-        return (quote.amountOut * 93n) / 100n; // Add 7% reduced fixed amount to cover fees
+        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),
+          }),
+        ]);
+
+        // Worst-case output already carries provider slippage; never use the nominal amountOut.
+        const swapOutput = quote.amountOutMin ?? quote.amountOut;
+        return estimateAmountOut(swapOutput, DEFAULT_COMMISSION_BPS, expenses, SINGLE_CHAIN_COMMISSION_DENOMINATOR);
       }
 
       case 'USE_PROVIDED_AMOUNT':

package/src/core/sdk.ts

@@ -1,9 +1,10 @@
-import { AUCTIONEER_URL, DEV_ACCESS_KEY } from '../constants.js';
+import { AUCTIONEER_URL } from '../constants.js';
 import { NetworkError } from '../errors/index.js';
 import type { ApiResponse } from '../types/api.js';
 import type {
   CrossChainOrderPrepared,
   CrossChainUserIntentRequest,
+  DcaCrossChainUserIntentRequest,
   DcaSingleChainOrderPrepared,
   DcaSingleChainUserIntentRequest,
   SingleChainOrderPrepared,
@@ -28,11 +29,7 @@ export abstract class BaseSDK {
   private static async makeRequest(url: string, body: string): Promise<ApiResponse> {
     const response = await fetch(url, {
       method: 'POST',
-      headers: {
-        'Content-Type': 'application/json', ...(DEV_ACCESS_KEY
-          ? { "x-dev-access": DEV_ACCESS_KEY }
-          : {}),
-      },
+      headers: { 'Content-Type': 'application/json' },
       body,
     });
 
@@ -126,4 +123,13 @@ export abstract class BaseSDK {
   public static async validateDcaSingleChainOrder(intentRequest: DcaSingleChainUserIntentRequest): Promise<void> {
     return BaseSDK.validateOrder(intentRequest, '/validate_intent/single_chain/dca_order');
   }
+
+  public static async validateDcaCrossChainOrder(intentRequest: DcaCrossChainUserIntentRequest): Promise<void> {
+    return BaseSDK.validateOrder(intentRequest, '/validate_intent/cross_chain/dca_order');
+  }
+
+  public static async sendDcaCrossChainOrder(intentRequest: DcaCrossChainUserIntentRequest): Promise<ApiResponse> {
+    const body = JSON.stringify(intentRequest, Parsers.bigIntReplacer);
+    return BaseSDK.makeRequest(`${AUCTIONEER_URL}/user_intent/cross_chain/dca_order`, body);
+  }
 }

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

@@ -60,7 +60,8 @@ export type CreateSolanaCrossChainOrderIntentParams = {
   deadline: number;
   extraTransfers?: ExtraTransfer[];
   orderPubkey?: string;
-  stopLossMaxOut?: bigint;
+  stopLossType?: StopLossType;
+  stopLossTriggerPrice?: string;
   takeProfitMinOut?: bigint;
 };
 
@@ -150,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,

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';
@@ -92,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;