@shogun-sdk/intents-sdk 1.3.0 → 1.4.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shogun-sdk/intents-sdk",
-  "version": "1.3.0",
+  "version": "1.4.0",
   "type": "module",
   "description": "Shogun Network Intent-based cross-chain swaps SDK",
   "author": "Shogun network",
@@ -12,13 +12,15 @@
     "type": "git",
     "url": "https://github.com/shogun-network/shogun-sdk.git"
   },
-  "main": "./dist/esm/index.js",
-  "types": "./dist/types/index.d.ts",
-  "typings": "./dist/types/index.d.ts",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
   "exports": {
     ".": {
-      "types": "./dist/types/index.d.ts",
-      "default": "./dist/esm/index.js"
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs",
+      "default": "./dist/index.js"
     },
     "./package.json": "./package.json"
   },
@@ -45,40 +47,51 @@
     "@types/bn.js": "5.2.0",
     "@types/node": "22.13.10",
     "codama": "1.3.4",
-    "typescript": "5.8.2"
+    "tsup": "^8.5.0",
+    "typescript": "5.8.2",
+    "vitest": "^2.1.9"
   },
   "dependencies": {
+    "@codama/visitors-core": "^1.3.7",
     "@coral-xyz/anchor": "0.31.1",
     "@jup-ag/api": "6.0.44",
     "@mysten/bcs": "1.8.0",
     "@mysten/sui": "1.29.1",
     "@paraswap/sdk": "7.3.1",
-    "@raydium-io/raydium-sdk-v2": "0.2.29-alpha",
+    "@raydium-io/raydium-sdk-v2": "0.2.30-alpha",
+    "@solana-program/system": "0.8.0",
+    "@solana-program/token": "0.6.0",
     "@solana/accounts": "3.0.3",
     "@solana/addresses": "3.0.3",
     "@solana/codecs": "3.0.3",
+    "@solana/compat": "3.0.2",
     "@solana/errors": "3.0.3",
     "@solana/instructions": "3.0.3",
+    "@solana/kit": "3.0.2",
     "@solana/programs": "3.0.3",
     "@solana/signers": "3.0.3",
-    "@solana/web3.js": "1.98.2",
-    "@uniswap/permit2-sdk": "1.4.0",
+    "@solana/transaction-confirmation": "3.0.2",
+    "@solana/transactions": "3.0.2",
+    "@solana/web3.js": "1.98.4",
+    "@uniswap/permit2-sdk": "1.3.0",
     "aftermath-ts-sdk": "1.3.14",
     "bn.js": "5.2.2",
     "dayjs": "1.11.13",
+    "decimal.js": "^10.4.3",
     "ethers": "6.13.5",
     "js-sha3": "0.9.3",
     "solana": "3.0.0",
-    "viem": "2.31.0"
+    "viem": "2.40.3"
   },
   "scripts": {
-    "build": "pnpm clean && pnpm build:esm+types",
-    "build:esm+types": "tsc --project ./tsconfig.build.json --outDir ./dist/esm --declaration --declarationMap --declarationDir ./dist/types",
-    "clean": "rm -rf ./dist",
+    "clean": "rm -rf dist",
+    "build": "tsup --clean",
     "check:types": "tsc --noEmit --project ./tsconfig.build.json",
     "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

@@ -24,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/chains.ts

@@ -22,6 +22,8 @@ export enum ChainID {
   Hyperliquid = 999,
   Solana = 7565164,
   Sui = 101,
+  BSC = 56,
+  MONAD = 143,
 }
 
 /**
@@ -35,6 +37,8 @@ export const SupportedChains = [
   ChainID.Hyperliquid,
   ChainID.Solana,
   ChainID.Sui,
+  ChainID.BSC,
+  ChainID.MONAD
 ] as const;
 
 /**
@@ -78,4 +82,6 @@ export const chainIdToChainTypeMap = {
   [ChainID.Hyperliquid]: ChainType.EVM,
   [ChainID.Solana]: ChainType.Solana,
   [ChainID.Sui]: ChainType.Sui,
+  [ChainID.BSC]: ChainType.EVM,
+  [ChainID.MONAD]: ChainType.EVM,
 } as const;

package/src/constants.ts

@@ -15,17 +15,21 @@ export const PERMIT2_ADDRESS: Record<SupportedEvmChain, EvmAddress> = {
   [ChainID.Optimism]: '0x000000000022d473030f116ddee9f6b43ac78ba3' as EvmAddress,
   [ChainID.Base]: '0x000000000022d473030f116ddee9f6b43ac78ba3' as EvmAddress,
   [ChainID.Hyperliquid]: '0x000000000022d473030f116ddee9f6b43ac78ba3' as EvmAddress,
+  [ChainID.BSC]: '0x000000000022d473030f116ddee9f6b43ac78ba3' as EvmAddress,
+  [ChainID.MONAD]: '0x000000000022d473030f116ddee9f6b43ac78ba3' as EvmAddress,
 };
 
 // Production guard addresses
 export const PROD_CROSS_CHAIN_GUARD_ADDRESSES: Record<SupportedChain, SolanaAddress | EvmAddress> = {
-  [ChainID.Arbitrum]: '0x45a245d20ee6ad18d04f85b2687725e033213ada' as EvmAddress,
-  [ChainID.Optimism]: '0x484dbead4922823bf0db26cc1b0ec9fa77e2695a' as EvmAddress,
-  [ChainID.Base]: '0x40904a219fbbe182b06e9aa71183d37f5d64ff1b' as EvmAddress,
-  [ChainID.Hyperliquid]: '0xd493dc28466b42b408aed664c2af8bf81c32a7a8' as EvmAddress,
+  [ChainID.Arbitrum]: '0x7f23f071be7d3161c026ae49289d34f3e7b89992' as EvmAddress,
+  [ChainID.Optimism]: '0x8c29c82c65a0a58311f0e8967580e08e548c4614' as EvmAddress,
+  [ChainID.Base]: '0x165d1187acf51a96faf6908e5d5cc459fe21fdba' as EvmAddress,
+  [ChainID.Hyperliquid]: '0xe5329801f8c0ee293286e8be253d009b01d4e54e' as EvmAddress,
   [ChainID.Solana]:
     'AiTqNSZe6Nxs2myiUX1cP6YfiER3v2pWuMYMSLYcrpyo' as SolanaAddress<'AiTqNSZe6Nxs2myiUX1cP6YfiER3v2pWuMYMSLYcrpyo'>,
   [ChainID.Sui]: '0x70d005df81d0fd7f7a7aaf87fa8676bff427f7202897b373bbf3d5bf0a8792de',
+  [ChainID.BSC]: '0x18bab93fad2a790a6635553451307d309b1de2b4' as EvmAddress,
+  [ChainID.MONAD]: '0x4E657A1386A6DB821cE764625Fb24BFbB54eA12E' as EvmAddress,
 };
 
 // Test guard addresses
@@ -37,6 +41,8 @@ export const TEST_CROSS_CHAIN_GUARD_ADDRESSES: Record<SupportedChain, SolanaAddr
   [ChainID.Solana]:
     '97XuksD34dyU3qyPDNwQ8qfPw1zHoUa7xVxBVdojSJ7E' as SolanaAddress<'97XuksD34dyU3qyPDNwQ8qfPw1zHoUa7xVxBVdojSJ7E'>,
   [ChainID.Sui]: '0x47f2934f621483bc485feeb78972dd2fb25840074e296fffb9e64f9bde6d2ff1',
+  [ChainID.BSC]: '0x41E46ea2a85E49c28A0cE313B4F7a6AEC1AfD852' as EvmAddress,
+  [ChainID.MONAD]: '0x0000000000000000000000000000000000000000' as EvmAddress,
 };
 
 // Prod guard addresses
@@ -45,11 +51,13 @@ export const PROD_SINGLE_CHAIN_GUARD_ADDRESSES: Record<
   SolanaAddress | EvmAddress
 > = {
   [ChainID.Arbitrum]: '0x0' as EvmAddress,
-  [ChainID.Optimism]: '0x0' as EvmAddress,
+  [ChainID.Optimism]: '0xdcbb658910b5192a43b79fd8244bdf27940d3b6b' as EvmAddress,
   [ChainID.Base]: '0x449808a27f42518c57791d4c2c6626f0069a0ed9' as EvmAddress,
   [ChainID.Hyperliquid]: '0x618ee9b6829261108d811b91581e00da192b0b75' as EvmAddress,
   [ChainID.Solana]:
     'CwWkajHjBCWMKZdwR5D1P5M6Fgf9dAyxqZ1qDZgZGo1e' as SolanaAddress<'CwWkajHjBCWMKZdwR5D1P5M6Fgf9dAyxqZ1qDZgZGo1e'>,
+  [ChainID.BSC]: '0xA69c47F93Ccc5BcCdc4b3c71646F61Fa5baa3323' as EvmAddress,
+  [ChainID.MONAD]: '0x8CBaa5Db68C1dC5485DbC8dd1f86b089614926E7' as EvmAddress,
 };
 
 // Test guard addresses
@@ -63,13 +71,29 @@ export const TEST_SINGLE_CHAIN_GUARD_ADDRESSES: Record<
   [ChainID.Hyperliquid]: '0x6a2f41f905035fa89b7329c0661061b580b1eb92' as EvmAddress,
   [ChainID.Solana]:
     '4wi5wsgSs9q9WV55s9AvKWTdeMNPcDXhzcbx5SoRRFcg' as SolanaAddress<'4wi5wsgSs9q9WV55s9AvKWTdeMNPcDXhzcbx5SoRRFcg'>,
+  [ChainID.BSC]: '0xBc68262535d2a8D42bA80c9bbF5299DfbfEc0040' as EvmAddress,
+  [ChainID.MONAD]: '0x0000000000000000000000000000000000000000' as EvmAddress,
 };
 
 export const PROD_DCA_SINGLE_CHAIN_GUARD_ADDRESSES: Record<SupportedEvmChain, EvmAddress> = {
   [ChainID.Arbitrum]: '0x0000000000000000000000000000000000000000' as EvmAddress,
-  [ChainID.Optimism]: '0x0000000000000000000000000000000000000000' as EvmAddress,
-  [ChainID.Base]: '0x1ab119e95a87ff59a57eba6dec6599aff8b2d7e4' as EvmAddress,
-  [ChainID.Hyperliquid]: '0x490911e5236f68ba921cbecc4b82b5e01b745731' as EvmAddress,
+  [ChainID.Optimism]: '0x1b754840f058b78e412156d2674b5954728cb86e' as EvmAddress,
+  [ChainID.Base]: '0x2df3ab1bb8b9d48769718003de2d8ca8e9d3c465' 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,
+};
+
+export const PROD_DCA_CROSS_CHAIN_GUARD_ADDRESSES: Record<SupportedEvmChain, EvmAddress> = {
+  [ChainID.Base]: '0x10fcdfdf20b4488f7da9036aa421ee51db6d436c' as EvmAddress,
+  [ChainID.Arbitrum]: '0xfd1bf54b0058240325cd865638444806146682b1' as EvmAddress,
+  [ChainID.BSC]: '0xaa704102bf25d4c87b0efc544c6008ed187ba011' as EvmAddress,
+  [ChainID.Hyperliquid]: '0xffef1e5af589e251d539576869d2a977846c85a2' as EvmAddress,
+  [ChainID.Optimism]: '0x386b310f137febfff79f72201dedef81501c1029' as EvmAddress,
+  [ChainID.MONAD]: '0x68D338b4a1499D93bcD2A9D3C921c8472cA4cE4e' as EvmAddress,
+
 };
 
 // Test guard addresses
@@ -78,6 +102,8 @@ export const TEST_DCA_SINGLE_CHAIN_GUARD_ADDRESSES: Record<SupportedEvmChain, Ev
   [ChainID.Optimism]: '0x0000000000000000000000000000000000000000' as EvmAddress,
   [ChainID.Base]: '0x79fd6a458066396c8938823049b6e614ce6b71f2' as EvmAddress,
   [ChainID.Hyperliquid]: '0x5156e6c7b7a1c60ed4d6b2175f88f1f6875c78d8' as EvmAddress,
+  [ChainID.BSC]: '0x25c283094f9EDA9F1455a1ecbEEf10c69311D962' as EvmAddress,
+  [ChainID.MONAD]: '0x0000000000000000000000000000000000000000' as EvmAddress,
 };
 
 export const CROSS_CHAIN_GUARD_ADDRESSES = useProdConfig
@@ -92,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 =
@@ -111,7 +141,7 @@ export const SOLANA_USDC_MINT = {
 
 export const SOLANA_MINT_TOKEN = SOLANA_USDC_MINT;
 
-export const PROD_SUI_PACKAGE_ID = '0x2c9b6a7a018f2f02663a1b2247e7e53d0bf832b30ab9534c49699a78a2f659f2'// '0x9c0c9b7f5ddf7efbde76571783ef4a8a26b36ae5c2ef2eeba8fbc604a29cb195';
+export const PROD_SUI_PACKAGE_ID = '0x2c9b6a7a018f2f02663a1b2247e7e53d0bf832b30ab9534c49699a78a2f659f2'; // '0x9c0c9b7f5ddf7efbde76571783ef4a8a26b36ae5c2ef2eeba8fbc604a29cb195';
 export const TEST_SUI_PACKAGE_ID = '0x2c9b6a7a018f2f02663a1b2247e7e53d0bf832b30ab9534c49699a78a2f659f2';
 export const SUI_PACKAGE_ID = useProdConfig ? PROD_SUI_PACKAGE_ID : TEST_SUI_PACKAGE_ID;
 
@@ -121,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;
@@ -140,6 +176,8 @@ export const WRAPPED_ETH_ADDRESSES: Record<SupportedEvmChain, EvmAddress> = {
   [ChainID.Optimism]: '0x4200000000000000000000000000000000000006' as EvmAddress,
   [ChainID.Base]: '0x4200000000000000000000000000000000000006' as EvmAddress,
   [ChainID.Hyperliquid]: '0x5555555555555555555555555555555555555555' as EvmAddress,
+  [ChainID.BSC]: '0xbb4CdB9CBd36B01bD1cBaEBF2De08d9173bc095c' as EvmAddress,
+  [ChainID.MONAD]: '0x3bd359C1119dA7Da1D913D1C4D2B7c461115433A' as EvmAddress,
 };
 
 export const NATIVE_SUI_TOKEN_ADDRESS = '0x0000000000000000000000000000000000000000000000000000000000000002::sui::SUI';
@@ -150,4 +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://token-search-api.vercel.app';
+export const EVM_ZERO_ADDRESS = '0x0000000000000000000000000000000000000000' as EvmAddress;
+
+/** 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/chain-provider.ts

@@ -12,7 +12,7 @@ import {
   type WalletClient,
 } from 'viem';
 import { privateKeyToAccount } from 'viem/accounts';
-import { arbitrum, base, optimism } from 'viem/chains';
+import { arbitrum, base, optimism, bsc, } from 'viem/chains';
 import { ChainID, type SupportedEvmChain } from '../../chains.js';
 import type { EVMConfig } from '../../config.js';
 import { ERC20ABI } from './abi/erc20.js';
@@ -20,12 +20,15 @@ import { SOURCE_CHAIN_GUARD_ABI } from './abi/source-chain-guard.js';
 import { PERMIT2_ABI } from './abi/permit2.js';
 import { SINGLE_CHAIN_GUARD_LIMIT_ABI } from './abi/single-chain-guard-limit.js';
 import { hyperEVM } from './connectors/hyperevm.js';
+import { monadMainnet } from './connectors/monad.js';
 
 export const chainIdToProviderChainMap: Record<SupportedEvmChain, Chain> = {
   [ChainID.Arbitrum]: arbitrum,
   [ChainID.Optimism]: optimism,
   [ChainID.Base]: base,
   [ChainID.Hyperliquid]: hyperEVM,
+  [ChainID.BSC]: bsc,
+  [ChainID.MONAD]: monadMainnet,
 };
 
 export class ChainProvider {

package/src/core/evm/connectors/monad.ts

@@ -0,0 +1,27 @@
+import { defineChain } from 'viem';
+
+export const monadMainnet = defineChain({
+    id: 143,
+    name: 'Monad Mainnet',
+    network: 'monad-mainnet',
+    nativeCurrency: {
+        name: 'Monad',
+        symbol: 'MON',
+        decimals: 18,
+    },
+    rpcUrls: {
+        default: {
+            http: ['https://rpc-mainnet.monadinfra.com', 'https://rpc4.monad.xyz', 'https://rpc3.monad.xyz', 'https://rpc1.monad.xyz'],
+        },
+        public: {
+            http: ['https://rpc-mainnet.monadinfra.com', 'https://rpc4.monad.xyz', 'https://rpc3.monad.xyz', 'https://rpc1.monad.xyz'],
+        },
+    },
+    blockExplorers: {
+        default: {
+            name: 'Monad Explorer',
+            url: 'https://monadscan.com',
+        },
+    },
+    testnet: false,
+});

package/src/core/evm/cross-chain-limit-order.ts

@@ -1,16 +1,16 @@
-import { ethers, type TypedDataField, type AddressLike, type BigNumberish } from "ethers";
-import { SignatureTransfer } from "@uniswap/permit2-sdk";
+import { ethers, type TypedDataField, type AddressLike, type BigNumberish } from 'ethers';
+import { SignatureTransfer } from '@uniswap/permit2-sdk';
 
 export const OrderInfoType: Record<string, TypedDataField[]> = {
   OrderInfo: [
-    { name: "user", type: "address" },
-    { name: "tokenIn", type: "address" },
-    { name: "srcChainId", type: "uint32" },
-    { name: "deadline", type: "uint32" },
-    { name: "amountIn", type: "uint128" },
-    { name: "minStablecoinsAmount", type: "uint128" },
-    { name: "executionDetailsHash", type: "bytes32" },
-    { name: "nonce", type: "uint256" },
+    { name: 'user', type: 'address' },
+    { name: 'tokenIn', type: 'address' },
+    { name: 'srcChainId', type: 'uint32' },
+    { name: 'deadline', type: 'uint32' },
+    { name: 'amountIn', type: 'uint128' },
+    { name: 'minStablecoinsAmount', type: 'uint128' },
+    { name: 'executionDetailsHash', type: 'bytes32' },
+    { name: 'nonce', type: 'uint256' },
   ],
 };
 
@@ -33,7 +33,7 @@ export async function signCrossChainLimitOrder(
   orderInfo: OrderInfoStruct,
   chainId: number,
   guardAddress: string,
-  permit2Address: string
+  permit2Address: string,
 ): Promise<{
   domain: any;
   types: any;
@@ -54,9 +54,9 @@ export async function signCrossChainLimitOrder(
     chainId,
     {
       witness: orderInfo,
-      witnessTypeName: "OrderInfo",
+      witnessTypeName: 'OrderInfo',
       witnessType: OrderInfoType,
-    }
+    },
   );
 
   return {
@@ -70,7 +70,7 @@ export async function signCrossChainLimitOrder(
         verifyingContract: permitData.domain.verifyingContract,
       },
       permitData.types,
-      permitData.values
+      permitData.values,
     ),
   };
 }

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

@@ -1,10 +1,27 @@
+import type { Address, Hex, TypedDataDefinition } from 'viem';
 import type { SupportedEvmChain } from '../../chains.js';
-import type { SingleChainUserIntentRequest, CrossChainUserIntentRequest, DcaSingleChainUserIntentRequest } from '../../types/intent.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';
 import type { DcaSingleChainOrder } from '../orders/dca-single-chain.js';
-import type { ExtraTransfer } from '../orders/common.js';
-import { getEVMCrossChainOrderTypedData, getEVMSingleChainOrderTypedData, getEVMDcaSingleChainOrderTypedData } from './order-signature.js';
+import type { ExtraTransfer, StopLossType } from '../orders/common.js';
+import {
+  getEVMCrossChainOrderTypedData,
+  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';
 
@@ -20,8 +37,9 @@ export type CreateEvmSingleChainLimitOrderIntentParams = {
   deadline: number;
   nonce?: string;
   signature?: string;
-  stopLossMaxOut?: bigint;
   takeProfitMinOut?: bigint;
+  stopLossType?: StopLossType;
+  stopLossTriggerPrice?: string;
 };
 
 export type CreateEvmSingleChainDcaOrderIntentParams = {
@@ -55,8 +73,9 @@ export type CreateEvmCrossChainOrderIntentParams = {
   extraTransfers?: ExtraTransfer[];
   nonce?: string;
   signature?: string;
-  stopLossMaxOut?: bigint;
   takeProfitMinOut?: bigint;
+  stopLossType?: StopLossType;
+  stopLossTriggerPrice?: string;
 };
 
 /**
@@ -65,7 +84,7 @@ export type CreateEvmCrossChainOrderIntentParams = {
  * @returns Formatted intent request ready to send to auctioneer
  */
 export function createEvmSingleChainLimitOrderIntentRequest(
-  params: CreateEvmSingleChainLimitOrderIntentParams
+  params: CreateEvmSingleChainLimitOrderIntentParams,
 ): SingleChainUserIntentRequest {
   const order: SingleChainOrder = {
     user: params.user,
@@ -77,8 +96,9 @@ export function createEvmSingleChainLimitOrderIntentRequest(
     destinationAddress: params.destinationAddress,
     extraTransfers: params.extraTransfers,
     deadline: params.deadline,
-    stopLossMaxOut: params.stopLossMaxOut,
     takeProfitMinOut: params.takeProfitMinOut,
+    stopLossType: params.stopLossType,
+    stopLossTriggerPrice: params.stopLossTriggerPrice,
   } as SingleChainOrder;
 
   return {
@@ -86,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,
       },
     },
   };
@@ -98,7 +118,7 @@ export function createEvmSingleChainLimitOrderIntentRequest(
  * @returns Formatted intent request ready to send to auctioneer
  */
 export function createEvmSingleChainDcaOrderIntentRequest(
-  params: CreateEvmSingleChainDcaOrderIntentParams
+  params: CreateEvmSingleChainDcaOrderIntentParams,
 ): DcaSingleChainUserIntentRequest {
   const order: DcaSingleChainOrder = {
     user: params.user,
@@ -120,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,
       },
     },
   };
@@ -132,7 +152,7 @@ export function createEvmSingleChainDcaOrderIntentRequest(
  * @returns Formatted intent request ready to send to auctioneer
  */
 export function createEvmCrossChainOrderIntentRequest(
-  params: CreateEvmCrossChainOrderIntentParams
+  params: CreateEvmCrossChainOrderIntentParams,
 ): CrossChainUserIntentRequest {
   const executionDetails = {
     destChainId: params.destinationChainId,
@@ -140,15 +160,14 @@ export function createEvmCrossChainOrderIntentRequest(
     amountOutMin: params.destinationTokenMinAmount?.toString() || '1',
     destinationAddress: params.destinationAddress,
     extraTransfers: params.extraTransfers,
-    stopLossMaxOut: params.stopLossMaxOut?.toString(),
     takeProfitMinOut: params.takeProfitMinOut?.toString(),
+    stopLossType: params.stopLossType,
+    stopLossTriggerPrice: params.stopLossTriggerPrice,
   };
   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,
@@ -159,8 +178,6 @@ export function createEvmCrossChainOrderIntentRequest(
     deadline: params.deadline,
     executionDetailsHash: executionDetailsHash as `0x${string}`,
     extraTransfers: params.extraTransfers,
-    stopLossMaxOut: params.stopLossMaxOut,
-    takeProfitMinOut: params.takeProfitMinOut,
   };
 
   return {
@@ -169,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,
       },
     },
   };
@@ -209,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,
+  };
+}