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

package/dist/index.js

@@ -129,7 +129,10 @@ function isNativeEvmToken(tokenAddress) {
   const normalizedAddress = tokenAddress.toLowerCase();
   return NATIVE_EVM_ETH_ADDRESSES.some((addr) => addr.toLowerCase() === normalizedAddress);
 }
-var useProdConfig, IntentsOrderType, PERMIT2_ADDRESS, PROD_CROSS_CHAIN_GUARD_ADDRESSES, TEST_CROSS_CHAIN_GUARD_ADDRESSES, PROD_SINGLE_CHAIN_GUARD_ADDRESSES, TEST_SINGLE_CHAIN_GUARD_ADDRESSES, PROD_DCA_SINGLE_CHAIN_GUARD_ADDRESSES, PROD_DCA_CROSS_CHAIN_GUARD_ADDRESSES, TEST_DCA_SINGLE_CHAIN_GUARD_ADDRESSES, CROSS_CHAIN_GUARD_ADDRESSES, SINGLE_CHAIN_GUARD_ADDRESSES, DCA_SINGLE_CHAIN_GUARD_ADDRESSES, NATIVE_SOLANA_TOKEN_ADDRESS, WRAPPED_SOL_MINT_ADDRESS, SOLANA_TIP_ACCOUNTS, SOLANA_MIN_TIP_LAMPORTS, SOLANA_USDC_MINT, SOLANA_MINT_TOKEN, PROD_SUI_PACKAGE_ID, TEST_SUI_PACKAGE_ID, SUI_PACKAGE_ID, SUI_GUARD_COLLATERAL_TYPE, SUI_GUARD_STABLECOIN_TYPE, AUCTIONEER_URL, MAX_UINT_32, MAX_UINT_64, MAX_UINT_128, MAX_UINT_256, NATIVE_EVM_ETH_ADDRESSES, WRAPPED_ETH_ADDRESSES, NATIVE_SUI_TOKEN_ADDRESS, TOKEN_SEARCH_API_BASE_URL;
+function normalizeNativeEvmTokenForSigning(tokenAddress) {
+  return isNativeEvmToken(tokenAddress) ? EVM_ZERO_ADDRESS : tokenAddress;
+}
+var useProdConfig, IntentsOrderType, PERMIT2_ADDRESS, PROD_CROSS_CHAIN_GUARD_ADDRESSES, TEST_CROSS_CHAIN_GUARD_ADDRESSES, PROD_SINGLE_CHAIN_GUARD_ADDRESSES, TEST_SINGLE_CHAIN_GUARD_ADDRESSES, PROD_DCA_SINGLE_CHAIN_GUARD_ADDRESSES, PROD_DCA_CROSS_CHAIN_GUARD_ADDRESSES, TEST_DCA_SINGLE_CHAIN_GUARD_ADDRESSES, CROSS_CHAIN_GUARD_ADDRESSES, SINGLE_CHAIN_GUARD_ADDRESSES, DCA_SINGLE_CHAIN_GUARD_ADDRESSES, DCA_CROSS_CHAIN_GUARD_ADDRESSES, NATIVE_SOLANA_TOKEN_ADDRESS, WRAPPED_SOL_MINT_ADDRESS, SOLANA_USDC_MINT, SOLANA_MINT_TOKEN, PROD_SUI_PACKAGE_ID, TEST_SUI_PACKAGE_ID, SUI_PACKAGE_ID, SUI_GUARD_COLLATERAL_TYPE, SUI_GUARD_STABLECOIN_TYPE, auctioneerUrlOverride, AUCTIONEER_URL, MAX_UINT_32, MAX_UINT_64, MAX_UINT_128, MAX_UINT_256, NATIVE_EVM_ETH_ADDRESSES, WRAPPED_ETH_ADDRESSES, NATIVE_SUI_TOKEN_ADDRESS, EVM_ZERO_ADDRESS, EVM_ZERO_SIGNATURE, TOKEN_SEARCH_API_BASE_URL;
 var init_constants = __esm({
   "src/constants.ts"() {
     "use strict";
@@ -189,7 +192,9 @@ var init_constants = __esm({
       [42161 /* Arbitrum */]: "0x0000000000000000000000000000000000000000",
       [10 /* Optimism */]: "0x1b754840f058b78e412156d2674b5954728cb86e",
       [8453 /* Base */]: "0x2df3ab1bb8b9d48769718003de2d8ca8e9d3c465",
-      [999 /* Hyperliquid */]: "0x618ee9b6829261108d811b91581e00da192b0b75",
+      // HyperEVM SingleChainGuardDca per the on-chain deployment + auctioneer config.
+      // (0x618ee9… is the SingleChainGuardLimit, which previously sat here by mistake.)
+      [999 /* Hyperliquid */]: "0xdcbb658910b5192a43b79fd8244bdf27940d3b6b",
       [56 /* BSC */]: "0x11ef880e2e8d17c114b9eb87369ce3d1311c62e1",
       [143 /* MONAD */]: "0x418302C3bef14D405A9B30381a9cb9d4d82EB2d4"
     };
@@ -212,21 +217,9 @@ var init_constants = __esm({
     CROSS_CHAIN_GUARD_ADDRESSES = useProdConfig ? PROD_CROSS_CHAIN_GUARD_ADDRESSES : TEST_CROSS_CHAIN_GUARD_ADDRESSES;
     SINGLE_CHAIN_GUARD_ADDRESSES = useProdConfig ? PROD_SINGLE_CHAIN_GUARD_ADDRESSES : TEST_SINGLE_CHAIN_GUARD_ADDRESSES;
     DCA_SINGLE_CHAIN_GUARD_ADDRESSES = useProdConfig ? PROD_DCA_SINGLE_CHAIN_GUARD_ADDRESSES : TEST_DCA_SINGLE_CHAIN_GUARD_ADDRESSES;
+    DCA_CROSS_CHAIN_GUARD_ADDRESSES = PROD_DCA_CROSS_CHAIN_GUARD_ADDRESSES;
     NATIVE_SOLANA_TOKEN_ADDRESS = "So11111111111111111111111111111111111111111";
     WRAPPED_SOL_MINT_ADDRESS = "So11111111111111111111111111111111111111112";
-    SOLANA_TIP_ACCOUNTS = [
-      "4ACfpUFoaSD9bfPdeu6DBt89gB6ENTeHBXCAi87NhDEE",
-      "D2L6yPZ2FmmmTKPgzaMKdhu6EWZcTpLy1Vhx8uvZe7NZ",
-      "9bnz4RShgq1hAnLnZbP8kbgBg1kEmcJBYQq3gQbmnSta",
-      "5VY91ws6B2hMmBFRsXkoAAdsPHBJwRfBht4DXox3xkwn",
-      "2nyhqdwKcJZR2vcqCyrYsaPVdAnFoJjiksCXJ7hfEYgD",
-      "2q5pghRs6arqVjRvT5gfgWfWcHWmw1ZuCzphgd5KfWGJ",
-      "wyvPkWjVZz1M8fHQnMMCDTQDbkManefNNhweYk5WkcF",
-      "3KCKozbAaF75qEU33jtzozcJ29yJuaLJTy2jFdzUY8bT",
-      "4vieeGHPYPG2MmyPRcYjdiDmmhN3ww7hsFNap8pVN3Ey",
-      "4TQLFNWK8AovT1gFvda5jfw2oJeRMKEmw7aH6MGBJ3or"
-    ];
-    SOLANA_MIN_TIP_LAMPORTS = 200000n;
     SOLANA_USDC_MINT = {
       name: "USDC",
       mint: "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v",
@@ -238,7 +231,8 @@ var init_constants = __esm({
     SUI_PACKAGE_ID = useProdConfig ? PROD_SUI_PACKAGE_ID : TEST_SUI_PACKAGE_ID;
     SUI_GUARD_COLLATERAL_TYPE = "0xdba34672e30cb065b1f93e3ab55318768fd6fef66c15942c9f7cb846e2f900e7::usdc::USDC";
     SUI_GUARD_STABLECOIN_TYPE = "0xdba34672e30cb065b1f93e3ab55318768fd6fef66c15942c9f7cb846e2f900e7::usdc::USDC";
-    AUCTIONEER_URL = useProdConfig ? "https://auctioneer-825534211396.us-central1.run.app" : "http://127.0.0.1:8080";
+    auctioneerUrlOverride = typeof process !== "undefined" ? process.env?.INTENTS_AUCTIONEER_URL : void 0;
+    AUCTIONEER_URL = auctioneerUrlOverride || (useProdConfig ? "https://auctioneer-825534211396.us-central1.run.app" : "http://127.0.0.1:8080");
     MAX_UINT_32 = 2n ** 32n - 1n;
     MAX_UINT_64 = 2n ** 64n - 1n;
     MAX_UINT_128 = 2n ** 128n - 1n;
@@ -256,6 +250,8 @@ var init_constants = __esm({
       [143 /* MONAD */]: "0x3bd359C1119dA7Da1D913D1C4D2B7c461115433A"
     };
     NATIVE_SUI_TOKEN_ADDRESS = "0x0000000000000000000000000000000000000000000000000000000000000002::sui::SUI";
+    EVM_ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";
+    EVM_ZERO_SIGNATURE = "0x0000000000000000000000000000000000000000000000000000000000000000";
     TOKEN_SEARCH_API_BASE_URL = "https://shogun-token-search-api-825534211396.europe-west4.run.app";
   }
 });
@@ -391,9 +387,6 @@ var BaseValidator = class {
     this.validateTokenAddress(order.tokenOut);
     this.validateAmount(order.amountIn);
     this.validateAmount(order.amountOutMin ?? 1n);
-    if (order.stopLossMaxOut) {
-      this.validateAmount(order.stopLossMaxOut);
-    }
     if (order.takeProfitMinOut) {
       this.validateAmount(order.takeProfitMinOut);
     }
@@ -443,9 +436,9 @@ var BaseValidator = class {
   /**
    * Helper methods that throw specific validation errors
    */
-  validateAddress(address10) {
-    if (!this.isValidAddress(address10)) {
-      throw new ValidationError(`Invalid ${this.getChainName()} address: ${address10}`);
+  validateAddress(address9) {
+    if (!this.isValidAddress(address9)) {
+      throw new ValidationError(`Invalid ${this.getChainName()} address: ${address9}`);
     }
   }
   validateTokenAddress(tokenAddress) {
@@ -3175,9 +3168,9 @@ var ChainProvider = class _ChainProvider {
       }
     });
   }
-  getSingleChainAuctioneerContract(address10) {
+  getSingleChainAuctioneerContract(address9) {
     return getContract({
-      address: address10,
+      address: address9,
       abi: SINGLE_CHAIN_GUARD_LIMIT_ABI,
       client: {
         wallet: this.walletClient,
@@ -3216,8 +3209,8 @@ var ChainProvider = class _ChainProvider {
 
 // src/core/evm/validator.ts
 var EvmValidator = class extends BaseValidator {
-  isValidAddress(address10) {
-    return isEvmAddress(address10);
+  isValidAddress(address9) {
+    return isEvmAddress(address9);
   }
   isValidTokenAddress(tokenAddress) {
     return isEvmAddress(tokenAddress);
@@ -3314,8 +3307,8 @@ var SolanaValidator = class extends BaseValidator {
   validateSingleChainOrderFeasability() {
     return Promise.resolve();
   }
-  isValidAddress(address10) {
-    return isSolanaAddress(address10);
+  isValidAddress(address9) {
+    return isSolanaAddress(address9);
   }
   isValidTokenAddress(tokenAddress) {
     return isSolanaAddress(tokenAddress);
@@ -3339,12 +3332,12 @@ init_constants();
 import { isValidSuiAddress, normalizeSuiAddress } from "@mysten/sui/utils";
 var SUI_TOKEN_ADDRESS_REGEX = /^0x[a-fA-F0-9]{64}::\w+::\w+$/;
 var SuiValidator = class extends BaseValidator {
-  isValidAddress(address10) {
-    return isValidSuiAddress(normalizeSuiAddress(address10));
+  isValidAddress(address9) {
+    return isValidSuiAddress(normalizeSuiAddress(address9));
   }
   isValidTokenAddress(tokenAddress) {
-    const [address10] = tokenAddress.split("::");
-    const isValidAddress = address10 !== void 0 ? this.isValidAddress(address10) : false;
+    const [address9] = tokenAddress.split("::");
+    const isValidAddress = address9 !== void 0 ? this.isValidAddress(address9) : false;
     return isValidAddress && SUI_TOKEN_ADDRESS_REGEX.test(tokenAddress);
   }
   isValidAmount(amount) {
@@ -3451,35 +3444,6 @@ var DcaSingleChainOrderValidator = class {
 init_constants();
 init_errors();
 
-// src/utils/auctioneer-headers.ts
-var DEV_ACCESS_STORAGE_KEY = "x-dev-access";
-var DEV_ACCESS_HEADER = "x-dev-access";
-function getDevAccessHeaderValue() {
-  try {
-    if (typeof globalThis === "undefined") {
-      return void 0;
-    }
-    const storage = globalThis.localStorage;
-    if (!storage?.getItem) {
-      return void 0;
-    }
-    const value = storage.getItem(DEV_ACCESS_STORAGE_KEY)?.trim();
-    return value ? value : void 0;
-  } catch {
-    return void 0;
-  }
-}
-function withAuctioneerHeaders(headers = {}) {
-  const value = getDevAccessHeaderValue();
-  if (!value) {
-    return headers;
-  }
-  return {
-    ...headers,
-    [DEV_ACCESS_HEADER]: value
-  };
-}
-
 // src/utils/parsers.ts
 import { formatUnits, parseUnits } from "viem";
 var Parsers;
@@ -3597,6 +3561,29 @@ var DCA_SINGLE_CHAIN_PERMIT2_TYPES = {
     { name: "witness", type: "SingleChainDcaOrder" }
   ]
 };
+var 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" }
+  ]
+};
 
 // src/core/evm/intent-provider.ts
 var EVMIntentProvider = class {
@@ -3663,12 +3650,12 @@ var EVMIntentProvider = class {
   static getSingleChainLimitPermissionMessage(order, nonce) {
     const spender = SINGLE_CHAIN_GUARD_ADDRESSES[order.chainId];
     const requestedOutput = {
-      token: order.tokenOut,
+      token: normalizeNativeEvmTokenForSigning(order.tokenOut),
       receiver: order.destinationAddress,
       amount: order.amountOutMin
     };
     const extraTransfers = order.extraTransfers?.map((transfer) => ({
-      token: transfer.token,
+      token: normalizeNativeEvmTokenForSigning(transfer.token),
       receiver: transfer.receiver,
       amount: transfer.amount
     })) || [];
@@ -3716,12 +3703,12 @@ var EVMIntentProvider = class {
   static getDcaSingleChainPermissionMessage(order, nonce) {
     const spender = DCA_SINGLE_CHAIN_GUARD_ADDRESSES[order.chainId];
     const requestedOutput = {
-      token: order.tokenOut,
+      token: normalizeNativeEvmTokenForSigning(order.tokenOut),
       receiver: order.destinationAddress,
       amount: BigInt(order.amountOutMin)
     };
     const extraTransfers = order.extraTransfers?.map((transfer) => ({
-      token: transfer.token,
+      token: normalizeNativeEvmTokenForSigning(transfer.token),
       receiver: transfer.receiver,
       amount: transfer.amount
     })) || [];
@@ -3796,10 +3783,10 @@ import {
   getSyncNativeInstruction
 } from "@solana-program/token";
 import {
-  address as address2,
+  address,
   addSignersToTransactionMessage,
   appendTransactionMessageInstructions,
-  createNoopSigner as createNoopSigner2,
+  createNoopSigner,
   createSolanaRpc as createSolanaRpc2,
   createTransactionMessage,
   fetchEncodedAccount as fetchEncodedAccount4,
@@ -3885,8 +3872,8 @@ function getOrderDecoder() {
 function decodeOrder(encodedAccount) {
   return decodeAccount(encodedAccount, getOrderDecoder());
 }
-async function fetchMaybeOrder(rpc, address10, config) {
-  const maybeAccount = await fetchEncodedAccount(rpc, address10, config);
+async function fetchMaybeOrder(rpc, address9, config) {
+  const maybeAccount = await fetchEncodedAccount(rpc, address9, config);
   return decodeOrder(maybeAccount);
 }
 
@@ -4126,8 +4113,8 @@ function getDcaOrderDecoder() {
 function decodeDcaOrder(encodedAccount) {
   return decodeAccount2(encodedAccount, getDcaOrderDecoder());
 }
-async function fetchMaybeDcaOrder(rpc, address10, config) {
-  const maybeAccount = await fetchEncodedAccount2(rpc, address10, config);
+async function fetchMaybeDcaOrder(rpc, address9, config) {
+  const maybeAccount = await fetchEncodedAccount2(rpc, address9, config);
   return decodeDcaOrder(maybeAccount);
 }
 
@@ -4173,8 +4160,8 @@ function getLimitOrderDecoder() {
 function decodeLimitOrder(encodedAccount) {
   return decodeAccount3(encodedAccount, getLimitOrderDecoder());
 }
-async function fetchMaybeLimitOrder(rpc, address10, config) {
-  const maybeAccount = await fetchEncodedAccount3(rpc, address10, config);
+async function fetchMaybeLimitOrder(rpc, address9, config) {
+  const maybeAccount = await fetchEncodedAccount3(rpc, address9, config);
   return decodeLimitOrder(maybeAccount);
 }
 
@@ -4554,77 +4541,20 @@ function formatTokenPubkey(token) {
   return token;
 }
 
-// src/core/solana/transaction-options.ts
-init_constants();
-import { address, createNoopSigner } from "@solana/kit";
-function resolveSolanaFeePayer(userSigner, feePayer) {
-  if (!feePayer || feePayer === userSigner.address) {
-    return userSigner;
-  }
-  const feePayerAddress = address(feePayer);
-  return createNoopSigner(feePayerAddress);
-}
-function resolveSolanaTip(options) {
-  const lamports = normalizeTipLamports(options);
-  if (!lamports) {
-    return void 0;
-  }
-  const selectedTipAccount = options?.tipAccount ?? pickRandomTipAccount(options?.tipAccounts ?? SOLANA_TIP_ACCOUNTS);
-  return {
-    lamports,
-    account: address(selectedTipAccount)
-  };
-}
-function normalizeTipLamports(options) {
-  if (!options) {
-    return void 0;
-  }
-  if (options.tipLamports !== void 0) {
-    if (options.tipLamports <= 0n) {
-      return void 0;
-    }
-    return options.tipLamports < SOLANA_MIN_TIP_LAMPORTS ? SOLANA_MIN_TIP_LAMPORTS : options.tipLamports;
-  }
-  if (options.tipAmountSol === void 0 || options.tipAmountSol === null || options.tipAmountSol === "") {
-    return void 0;
-  }
-  const tipInSol = Number(options.tipAmountSol);
-  if (!Number.isFinite(tipInSol)) {
-    throw new Error("Invalid Solana tip amount");
-  }
-  if (tipInSol <= 0) {
-    return void 0;
-  }
-  const tipLamports = BigInt(Math.round(tipInSol * 1e9));
-  return tipLamports < SOLANA_MIN_TIP_LAMPORTS ? SOLANA_MIN_TIP_LAMPORTS : tipLamports;
-}
-function pickRandomTipAccount(accounts) {
-  if (!accounts.length) {
-    throw new Error("No Solana tip accounts configured");
-  }
-  const index = Math.floor(Math.random() * accounts.length);
-  const selected = accounts[index];
-  if (!selected) {
-    throw new Error("No Solana tip account selected");
-  }
-  return selected;
-}
-
 // src/core/solana/order-instructions.ts
 async function getSolanaSingleChainOrderInstructions(order, options) {
   const rpc = options?.rpcUrl ? createSolanaRpc2(options.rpcUrl) : getDefaultSolanaRPC();
   const orderSigner = await generateKeyPairSigner();
-  const userSigner = createNoopSigner2(order.user);
-  const feePayerSigner = resolveSolanaFeePayer(userSigner, options?.feePayer);
-  let tokenInMint = address2(order.tokenIn);
+  const signer = createNoopSigner(order.user);
+  let tokenInMint = address(order.tokenIn);
   const { secretHash, secretNumber } = genSecretHashAndNumber(order);
-  const orderUserAddress = address2(order.user);
+  const orderUserAddress = address(order.user);
   const spendingNative = tokenInMint === NATIVE_SOLANA_TOKEN_ADDRESS;
   if (spendingNative) {
     tokenInMint = WRAPPED_SOL_MINT_ADDRESS;
   }
   const tokenMintProgram = await fetchMint(rpc, tokenInMint);
-  const guardAddress = address2(SINGLE_CHAIN_GUARD_ADDRESSES[7565164 /* Solana */]);
+  const guardAddress = address(SINGLE_CHAIN_GUARD_ADDRESSES[7565164 /* Solana */]);
   const addressEncoder = getAddressEncoder7();
   const instructions = [];
   const [tokenInProgramAccount] = await getProgramDerivedAddress4({
@@ -4638,7 +4568,7 @@ async function getSolanaSingleChainOrderInstructions(order, options) {
   const userTokenInAccount = await fetchEncodedAccount4(rpc, tokenInProgramAccount);
   if (!userTokenInAccount.exists) {
     const createAccountIx = await getCreateAssociatedTokenInstructionAsync({
-      payer: feePayerSigner,
+      payer: signer,
       ata: tokenInProgramAccount,
       owner: orderUserAddress,
       mint: tokenMintProgram.address,
@@ -4650,7 +4580,7 @@ async function getSolanaSingleChainOrderInstructions(order, options) {
     const transferIx = getTransferSolInstruction({
       amount: order.amountIn,
       destination: userTokenInAccount.address,
-      source: userSigner
+      source: signer
     });
     instructions.push(transferIx);
     const syncNativeIx = getSyncNativeInstruction({
@@ -4659,7 +4589,7 @@ async function getSolanaSingleChainOrderInstructions(order, options) {
     instructions.push(syncNativeIx);
   }
   const createSingleChainLimitOrderIx = await getCreateLimitOrderInstructionAsync({
-    user: userSigner,
+    user: signer,
     order: orderSigner,
     guard: guardAddress,
     tokenInMint,
@@ -4673,20 +4603,10 @@ async function getSolanaSingleChainOrderInstructions(order, options) {
     // TODO
   });
   instructions.push(createSingleChainLimitOrderIx);
-  const tip = resolveSolanaTip(options);
-  if (tip) {
-    instructions.push(
-      getTransferSolInstruction({
-        source: feePayerSigner,
-        destination: tip.account,
-        amount: tip.lamports
-      })
-    );
-  }
   const { value: latestBlockhash } = await rpc.getLatestBlockhash({ commitment: "confirmed" }).send();
   const txMessage = pipe(
     createTransactionMessage({ version: 0 }),
-    (tx) => setTransactionMessageFeePayerSigner(feePayerSigner, tx),
+    (tx) => setTransactionMessageFeePayerSigner(signer, tx),
     (tx) => setTransactionMessageLifetimeUsingBlockhash(latestBlockhash, tx),
     (tx) => appendTransactionMessageInstructions(instructions, tx),
     (tx) => addSignersToTransactionMessage([orderSigner], tx)
@@ -4702,16 +4622,15 @@ async function getSolanaSingleChainOrderInstructions(order, options) {
 async function getSolanaCrossChainOrderInstructions(order, options) {
   const rpc = options?.rpcUrl ? createSolanaRpc2(options.rpcUrl) : getDefaultSolanaRPC();
   const orderSigner = await generateKeyPairSigner();
-  const userSigner = createNoopSigner2(order.user);
-  const feePayerSigner = resolveSolanaFeePayer(userSigner, options?.feePayer);
-  let tokenInMint = address2(order.sourceTokenAddress);
-  const orderUserAddress = address2(order.user);
+  const signer = createNoopSigner(order.user);
+  let tokenInMint = address(order.sourceTokenAddress);
+  const orderUserAddress = address(order.user);
   const spendingNative = tokenInMint === NATIVE_SOLANA_TOKEN_ADDRESS;
   if (spendingNative) {
     tokenInMint = WRAPPED_SOL_MINT_ADDRESS;
   }
   const tokenMintProgram = await fetchMint(rpc, tokenInMint);
-  const guardAddress = address2(CROSS_CHAIN_GUARD_ADDRESSES[7565164 /* Solana */]);
+  const guardAddress = address(CROSS_CHAIN_GUARD_ADDRESSES[7565164 /* Solana */]);
   const addressEncoder = getAddressEncoder7();
   const [tokenInProgramAccount] = await getProgramDerivedAddress4({
     programAddress: ASSOCIATED_TOKEN_PROGRAM_ADDRESS,
@@ -4738,7 +4657,7 @@ async function getSolanaCrossChainOrderInstructions(order, options) {
     order.sourceTokenAddress = WRAPPED_SOL_MINT_ADDRESS;
     if (!userTokenInAccount.exists) {
       const createAccountIx = await getCreateAssociatedTokenInstructionAsync({
-        payer: feePayerSigner,
+        payer: signer,
         ata: tokenInProgramAccount,
         owner: orderUserAddress,
         mint: tokenMintProgram.address,
@@ -4747,7 +4666,7 @@ async function getSolanaCrossChainOrderInstructions(order, options) {
       instructions.push(createAccountIx);
     }
     const transferIx = getTransferSolInstruction({
-      source: userSigner,
+      source: signer,
       destination: userTokenInAccount.address,
       amount: order.sourceTokenAmount
     });
@@ -4759,9 +4678,9 @@ async function getSolanaCrossChainOrderInstructions(order, options) {
   }
   const executionHashUint8Array = order.executionDetailsHashToBytes();
   const createOrderIx = getCreateOrderInstruction({
-    user: userSigner,
+    user: signer,
     order: orderSigner,
-    guard: address2(CROSS_CHAIN_GUARD_ADDRESSES[7565164 /* Solana */]),
+    guard: address(CROSS_CHAIN_GUARD_ADDRESSES[7565164 /* Solana */]),
     systemProgram: SYSTEM_PROGRAM_ADDRESS,
     associatedTokenProgram: ASSOCIATED_TOKEN_PROGRAM_ADDRESS,
     tokenInMint,
@@ -4774,20 +4693,10 @@ async function getSolanaCrossChainOrderInstructions(order, options) {
     minStablecoinsAmount: order.minStablecoinAmount
   });
   instructions.push(createOrderIx);
-  const tip = resolveSolanaTip(options);
-  if (tip) {
-    instructions.push(
-      getTransferSolInstruction({
-        source: feePayerSigner,
-        destination: tip.account,
-        amount: tip.lamports
-      })
-    );
-  }
   const { value: latestBlockhash } = await rpc.getLatestBlockhash({ commitment: "confirmed" }).send();
   const txMessage = pipe(
     createTransactionMessage({ version: 0 }),
-    (tx) => setTransactionMessageFeePayerSigner(feePayerSigner, tx),
+    (tx) => setTransactionMessageFeePayerSigner(signer, tx),
     (tx) => setTransactionMessageLifetimeUsingBlockhash(latestBlockhash, tx),
     (tx) => appendTransactionMessageInstructions(instructions, tx),
     (tx) => addSignersToTransactionMessage([orderSigner], tx)
@@ -5394,11 +5303,11 @@ var RaydiumQuoteProvider = class {
 };
 
 // src/utils/quote/pumpfun/index.ts
-import { address as address4 } from "@solana/kit";
+import { address as address3 } from "@solana/kit";
 
 // src/utils/quote/pumpfun/utils.ts
 import {
-  address as address3,
+  address as address2,
   fetchEncodedAccount as fetchEncodedAccount5,
   fetchEncodedAccounts as fetchEncodedAccounts4,
   getAddressEncoder as getAddressEncoder8,
@@ -5476,10 +5385,10 @@ function getGlobalConfigDecoder() {
 
 // src/utils/quote/pumpfun/utils.ts
 import { getTokenDecoder } from "@solana-program/token";
-var PUMP_FUN_PROGRAM_ADDRESS = address3("6EF8rrecthR5Dkzon8Nwu78hRvfCKubJ14M5uBEwF6P");
-var PUMP_FUN_AMM_PROGRAM_ADDRESS = address3("pAMMBay6oceH9fJKBRHGP5D4bD4sWpmSwMn52FMfXEA");
-var WRAPPED_NATIVE_TOKEN_PUBKEY = address3("So11111111111111111111111111111111111111112");
-var GLOBAL_CONFIG_AMM = address3("ADyA8hdefvWN2dbGGWFotbzWxrAvLW83WG6QCVXvJKqw");
+var PUMP_FUN_PROGRAM_ADDRESS = address2("6EF8rrecthR5Dkzon8Nwu78hRvfCKubJ14M5uBEwF6P");
+var PUMP_FUN_AMM_PROGRAM_ADDRESS = address2("pAMMBay6oceH9fJKBRHGP5D4bD4sWpmSwMn52FMfXEA");
+var WRAPPED_NATIVE_TOKEN_PUBKEY = address2("So11111111111111111111111111111111111111112");
+var GLOBAL_CONFIG_AMM = address2("ADyA8hdefvWN2dbGGWFotbzWxrAvLW83WG6QCVXvJKqw");
 var ANCHOR_DISCRIMINATOR_SIZE = 8;
 var globalAccountCache = null;
 var globalConfigCache = null;
@@ -5885,8 +5794,8 @@ function estimatePumpFunAmm(baseToken, quoteToken, globalConfig, amount, tradeTy
 // src/utils/quote/pumpfun/index.ts
 var PumpFunQuoteProvider = class {
   async getQuote(raydiumParams) {
-    const inputMint = address4(raydiumParams.inputMint);
-    const outputMint = address4(raydiumParams.outputMint);
+    const inputMint = address3(raydiumParams.inputMint);
+    const outputMint = address3(raydiumParams.outputMint);
     const [inputBondingCurve, outputBondingCurve] = await this.getTokensBondingCurve(inputMint, outputMint);
     const { bondingCurve, isInputPrebonded } = this.ensureSinglePrebondedToken(inputBondingCurve, outputBondingCurve);
     let isInputSol = inputMint === NATIVE_SOLANA_TOKEN_ADDRESS || inputMint === WRAPPED_SOL_MINT_ADDRESS;
@@ -6147,10 +6056,93 @@ var RelayQuoteProvider = class {
   }
 };
 
-// src/utils/quote/aggregator.ts
-var compareAddresses2 = (firstAddress, secondAddress) => {
+// src/utils/quote/pricing/decimals.ts
+function convertDecimals(amount, fromDecimals, toDecimals) {
+  const diff = toDecimals - fromDecimals;
+  if (diff >= 0) {
+    return amount * 10n ** BigInt(diff);
+  }
+  return amount / 10n ** BigInt(-diff);
+}
+
+// src/utils/quote/pricing/estimate-amount-out.ts
+var IntentNotViableError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "IntentNotViableError";
+  }
+};
+function estimateAmountOut(swapOutput, commissionBps, expenses, commissionDenominator = 10000n) {
+  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;
+}
+
+// src/utils/quote/pricing/expenses.ts
+init_constants();
+
+// src/utils/quote/address.ts
+function compareAddresses2(firstAddress, secondAddress) {
   return !!firstAddress && !!secondAddress && firstAddress.toLowerCase() === secondAddress.toLowerCase();
+}
+
+// src/utils/quote/pricing/gas.ts
+init_chains();
+import { getGasPrice } from "viem/actions";
+
+// src/utils/quote/pricing/constants.ts
+var DEFAULT_COMMISSION_BPS = 50n;
+var SINGLE_CHAIN_COMMISSION_DENOMINATOR = 10000n;
+var CROSS_CHAIN_COMMISSION_DENOMINATOR = 100000n;
+var EVM_SINGLE_CHAIN_GAS_LIMIT = 3000000n;
+var EVM_CROSS_CHAIN_GAS_LIMIT = 2000000n;
+var NON_EVM_FIXED_NATIVE_GAS_COST = {
+  [101 /* Sui */]: 20000000n,
+  [7565164 /* Solana */]: 200000n
 };
+
+// src/utils/quote/pricing/gas.ts
+async function getNativeGasCost(params) {
+  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 === void 0) {
+    throw new Error(`No fixed native gas cost configured for chain ${chainId}`);
+  }
+  return fixed;
+}
+
+// src/utils/quote/pricing/expenses.ts
+function nativeTokenAddressForChain(chainId) {
+  if (chainId === 7565164 /* Solana */) return NATIVE_SOLANA_TOKEN_ADDRESS;
+  if (chainId === 101 /* Sui */) return NATIVE_SUI_TOKEN_ADDRESS;
+  return NATIVE_EVM_ETH_ADDRESSES[0];
+}
+function isNativeToken(chainId, address9) {
+  if (chainId === 7565164 /* Solana */) return compareAddresses2(address9, NATIVE_SOLANA_TOKEN_ADDRESS);
+  if (chainId === 101 /* Sui */) return compareAddresses2(address9, NATIVE_SUI_TOKEN_ADDRESS);
+  return isNativeEvmToken(address9);
+}
+async function estimateExpensesInTokenOut(params) {
+  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 };
+}
+
+// src/utils/quote/aggregator.ts
 var QuoteProvider = class _QuoteProvider {
   static async getQuote(params) {
     try {
@@ -6167,6 +6159,7 @@ var QuoteProvider = 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");
     }
@@ -6196,9 +6189,19 @@ var QuoteProvider = class _QuoteProvider {
       tokenIn: params.tokenIn,
       tokenOut: sourceStable.address
     };
-    const sourceQuote = await this.getSingleChainQuote(sourceSingleChainQuoteParams);
-    const normalizedBridgeAmount = BigInt(
-      Math.floor(Number(sourceQuote.amountOut) / 10 ** sourceStable.decimals * 10 ** destStable.decimals)
+    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)
+      })
+    ]);
+    const normalizedBridgeAmount = convertDecimals(
+      sourceQuote.amountOut,
+      sourceStable.decimals,
+      destStable.decimals
     );
     const destSingleChainQuoteParams = {
       chainId: params.destChainId,
@@ -6210,12 +6213,19 @@ var QuoteProvider = class _QuoteProvider {
     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
     };
   }
@@ -6674,7 +6684,10 @@ var CrossChainOrder = class _CrossChainOrder {
       tokenOut: this.destinationTokenAddress,
       destinationAddress: this.destinationAddress,
       amountOutMin: this.destinationTokenMinAmount,
-      extraTransfers: this.extraTransfers
+      extraTransfers: this.extraTransfers,
+      stopLossType: this.stopLossType,
+      stopLossTriggerPrice: this.stopLossTriggerPrice,
+      takeProfitMinOut: this.takeProfitMinOut
     };
   }
   executionDetailsHashToBytes() {
@@ -6855,13 +6868,22 @@ var SingleChainOrder = class _SingleChainOrder {
     });
     switch (scenario) {
       case "QUOTE_REQUIRED": {
-        const quote = await QuoteProvider.getSingleChainQuote({
-          tokenIn: input.tokenIn,
-          amount: input.amountIn,
-          chainId: input.chainId,
-          tokenOut: input.tokenOut
-        });
-        return quote.amountOut * 93n / 100n;
+        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)
+          })
+        ]);
+        const swapOutput = quote.amountOutMin ?? quote.amountOut;
+        return estimateAmountOut(swapOutput, DEFAULT_COMMISSION_BPS, expenses, SINGLE_CHAIN_COMMISSION_DENOMINATOR);
       }
       case "USE_PROVIDED_AMOUNT":
         return amountOutMin;
@@ -6921,7 +6943,7 @@ var BaseSDK = class _BaseSDK {
   static async makeRequest(url, body) {
     const response = await fetch(url, {
       method: "POST",
-      headers: withAuctioneerHeaders({ "Content-Type": "application/json" }),
+      headers: { "Content-Type": "application/json" },
       body
     });
     console.debug(`url`, url, `body`, body);
@@ -6990,14 +7012,21 @@ var BaseSDK = class _BaseSDK {
   static async validateDcaSingleChainOrder(intentRequest) {
     return _BaseSDK.validateOrder(intentRequest, "/validate_intent/single_chain/dca_order");
   }
+  static async validateDcaCrossChainOrder(intentRequest) {
+    return _BaseSDK.validateOrder(intentRequest, "/validate_intent/cross_chain/dca_order");
+  }
+  static async sendDcaCrossChainOrder(intentRequest) {
+    const body = JSON.stringify(intentRequest, Parsers.bigIntReplacer);
+    return _BaseSDK.makeRequest(`${AUCTIONEER_URL}/user_intent/cross_chain/dca_order`, body);
+  }
 };
 
 // src/core/solana/dca/create-order.ts
 import {
-  address as address5,
+  address as address4,
   addSignersToTransactionMessage as addSignersToTransactionMessage2,
   appendTransactionMessageInstructions as appendTransactionMessageInstructions2,
-  createNoopSigner as createNoopSigner3,
+  createNoopSigner as createNoopSigner2,
   createSolanaRpc as createSolanaRpc3,
   createTransactionMessage as createTransactionMessage2,
   fetchEncodedAccount as fetchEncodedAccount6,
@@ -7021,17 +7050,16 @@ import { getTransferSolInstruction as getTransferSolInstruction2 } from "@solana
 async function getSolanaDcaSingleChainOrderInstructions(order, options) {
   const rpc = options?.rpcUrl ? createSolanaRpc3(options.rpcUrl) : getDefaultSolanaRPC();
   const orderSigner = await generateKeyPairSigner2();
-  const userSigner = createNoopSigner3(order.user);
-  const feePayerSigner = resolveSolanaFeePayer(userSigner, options?.feePayer);
-  let tokenInMint = address5(order.tokenIn);
+  const signer = createNoopSigner2(order.user);
+  let tokenInMint = address4(order.tokenIn);
   const { secretHash, secretNumber } = genSecretHashAndNumber(order);
-  const orderUserAddress = address5(order.user);
+  const orderUserAddress = address4(order.user);
   const spendingNative = tokenInMint === NATIVE_SOLANA_TOKEN_ADDRESS;
   if (spendingNative) {
     tokenInMint = WRAPPED_SOL_MINT_ADDRESS;
   }
   const tokenMintProgram = await fetchMint2(rpc, tokenInMint);
-  const guardAddress = address5(SINGLE_CHAIN_GUARD_ADDRESSES[7565164 /* Solana */]);
+  const guardAddress = address4(SINGLE_CHAIN_GUARD_ADDRESSES[7565164 /* Solana */]);
   const addressEncoder = getAddressEncoder9();
   const instructions = [];
   const [tokenInProgramAccount] = await getProgramDerivedAddress6({
@@ -7045,7 +7073,7 @@ async function getSolanaDcaSingleChainOrderInstructions(order, options) {
   const userTokenInAccount = await fetchEncodedAccount6(rpc, tokenInProgramAccount);
   if (!userTokenInAccount.exists) {
     const createAccountIx = await getCreateAssociatedTokenInstructionAsync2({
-      payer: feePayerSigner,
+      payer: signer,
       ata: tokenInProgramAccount,
       owner: orderUserAddress,
       mint: tokenMintProgram.address,
@@ -7058,7 +7086,7 @@ async function getSolanaDcaSingleChainOrderInstructions(order, options) {
     const transferIx = getTransferSolInstruction2({
       amount: totalAmountIn,
       destination: userTokenInAccount.address,
-      source: userSigner
+      source: signer
     });
     instructions.push(transferIx);
     const syncNativeIx = getSyncNativeInstruction2({
@@ -7067,7 +7095,7 @@ async function getSolanaDcaSingleChainOrderInstructions(order, options) {
     instructions.push(syncNativeIx);
   }
   const createDcaOrderIx = await getCreateDcaOrderInstructionAsync({
-    user: userSigner,
+    user: signer,
     order: orderSigner,
     guard: guardAddress,
     tokenInMint,
@@ -7083,20 +7111,10 @@ async function getSolanaDcaSingleChainOrderInstructions(order, options) {
     // TODO: Implement extra transfers
   });
   instructions.push(createDcaOrderIx);
-  const tip = resolveSolanaTip(options);
-  if (tip) {
-    instructions.push(
-      getTransferSolInstruction2({
-        source: feePayerSigner,
-        destination: tip.account,
-        amount: tip.lamports
-      })
-    );
-  }
   const { value: latestBlockhash } = await rpc.getLatestBlockhash({ commitment: "confirmed" }).send();
   const txMessage = pipe2(
     createTransactionMessage2({ version: 0 }),
-    (tx) => setTransactionMessageFeePayerSigner2(feePayerSigner, tx),
+    (tx) => setTransactionMessageFeePayerSigner2(signer, tx),
     (tx) => setTransactionMessageLifetimeUsingBlockhash2(latestBlockhash, tx),
     (tx) => appendTransactionMessageInstructions2(instructions, tx),
     (tx) => addSignersToTransactionMessage2([orderSigner], tx)
@@ -7227,9 +7245,7 @@ import "viem";
 init_constants();
 async function fetchSiweMessage(params) {
   const url = `${AUCTIONEER_URL}/siwe?wallet=${params.wallet}&chainId=${params.chainId}`;
-  const response = await fetch(url, {
-    headers: withAuctioneerHeaders()
-  });
+  const response = await fetch(url);
   if (!response.ok) {
     throw new Error(`Failed to fetch SIWE message: ${response.status} ${response.statusText}`);
   }
@@ -7238,12 +7254,14 @@ async function fetchSiweMessage(params) {
 }
 async function fetchJWTToken(params, token) {
   const url = `${AUCTIONEER_URL}/siwe`;
+  const headers = { "Content-Type": "application/json" };
+  if (token) {
+    headers.Authorization = `Bearer ${token}`;
+  }
   const response = await fetch(url, {
     method: "POST",
     body: JSON.stringify(params),
-    headers: withAuctioneerHeaders({
-      Authorization: `Bearer ${token}`
-    })
+    headers
   });
   if (!response.ok) {
     throw new Error(`Failed to fetch JWT token: ${response.status} ${response.statusText}`);
@@ -7410,11 +7428,11 @@ var EVMSDK = class extends BaseSDK {
 
 // src/core/solana/sdk.ts
 import {
-  address as address8,
+  address as address7,
   appendTransactionMessageInstructions as appendTransactionMessageInstructions4,
   compileTransaction,
   createKeyPairFromBytes,
-  createNoopSigner as createNoopSigner6,
+  createNoopSigner as createNoopSigner5,
   createSignableMessage,
   createSignerFromKeyPair,
   createTransactionMessage as createTransactionMessage4,
@@ -7431,10 +7449,10 @@ import {
 
 // src/core/solana/cancel-order.ts
 import {
-  address as address6,
+  address as address5,
   appendTransactionMessageInstructions as appendTransactionMessageInstructions3,
   compileTransactionMessage,
-  createNoopSigner as createNoopSigner4,
+  createNoopSigner as createNoopSigner3,
   createSolanaRpc as createSolanaRpc4,
   createTransactionMessage as createTransactionMessage3,
   fetchEncodedAccount as fetchEncodedAccount7,
@@ -7453,7 +7471,7 @@ import {
 } from "@solana-program/token";
 async function cancelSingleChainOrderInstructions(orderAddress, options) {
   const rpc = options?.rpcUrl ? createSolanaRpc4(options.rpcUrl) : getDefaultSolanaRPC();
-  const orderId = address6(orderAddress);
+  const orderId = address5(orderAddress);
   const chainOrder = await fetchMaybeLimitOrder(rpc, orderId);
   if (!chainOrder.exists) {
     throw new Error(`Order with address ${orderAddress} not found`);
@@ -7488,7 +7506,7 @@ async function cancelSingleChainOrderInstructions(orderAddress, options) {
     const createTokenIx = await getCreateAssociatedTokenInstructionAsync3({
       mint: tokenInMint,
       owner: orderUserAddress,
-      payer: createNoopSigner4(orderUserAddress),
+      payer: createNoopSigner3(orderUserAddress),
       tokenProgram: tokenMintProgram.programAddress
     });
     instructions.push(createTokenIx);
@@ -7500,7 +7518,7 @@ async function cancelSingleChainOrderInstructions(orderAddress, options) {
     userTokenInAccount: userTokenInAccount.address,
     guardTokenInAccount: guardProgramAccount,
     tokenInProgram: tokenMintProgram.programAddress,
-    signer: createNoopSigner4(orderUserAddress),
+    signer: createNoopSigner3(orderUserAddress),
     user: orderUserAddress
   });
   instructions.push(cancelLimitOrderIx);
@@ -7512,7 +7530,7 @@ async function cancelCrossChainOrderInstructionsAsBytes(orderAddress, signerAddr
   const { value: latestBlockhash } = await rpc.getLatestBlockhash({ commitment: "confirmed" }).send();
   const txMessage = pipe3(
     createTransactionMessage3({ version: 0 }),
-    (tx) => setTransactionMessageFeePayerSigner3(createNoopSigner4(address6(signerAddress)), tx),
+    (tx) => setTransactionMessageFeePayerSigner3(createNoopSigner3(address5(signerAddress)), tx),
     (tx) => setTransactionMessageLifetimeUsingBlockhash3(latestBlockhash, tx),
     (tx) => appendTransactionMessageInstructions3(instructions, tx)
   );
@@ -7526,7 +7544,7 @@ async function cancelSingleChainOrderInstructionsAsBytes(orderAddress, signerAdd
   const { value: latestBlockhash } = await rpc.getLatestBlockhash({ commitment: "confirmed" }).send();
   const txMessage = pipe3(
     createTransactionMessage3({ version: 0 }),
-    (tx) => setTransactionMessageFeePayerSigner3(createNoopSigner4(address6(signerAddress)), tx),
+    (tx) => setTransactionMessageFeePayerSigner3(createNoopSigner3(address5(signerAddress)), tx),
     (tx) => setTransactionMessageLifetimeUsingBlockhash3(latestBlockhash, tx),
     (tx) => appendTransactionMessageInstructions3(instructions, tx)
   );
@@ -7536,7 +7554,7 @@ async function cancelSingleChainOrderInstructionsAsBytes(orderAddress, signerAdd
 }
 async function cancelCrossChainOrderInstructions(orderAddress, options) {
   const rpc = options?.rpcUrl ? createSolanaRpc4(options.rpcUrl) : getDefaultSolanaRPC();
-  const orderId = address6(orderAddress);
+  const orderId = address5(orderAddress);
   const chainOrder = await fetchMaybeOrder(rpc, orderId);
   if (!chainOrder.exists) {
     throw new Error(`Order with address ${orderAddress} not found`);
@@ -7546,7 +7564,7 @@ async function cancelCrossChainOrderInstructions(orderAddress, options) {
   const guardAddress = CROSS_CHAIN_GUARD_ADDRESSES[7565164 /* Solana */];
   const addressEncoder = getAddressEncoder10();
   const isRecoveringTokenIn = chainOrder.data.lockedStablecoins === 0n;
-  const recoverTokenMint = isRecoveringTokenIn ? chainOrder.data.tokenInMint : address6(SOLANA_MINT_TOKEN.mint);
+  const recoverTokenMint = isRecoveringTokenIn ? chainOrder.data.tokenInMint : address5(SOLANA_MINT_TOKEN.mint);
   const recoverTokenMintProgram = await fetchMint3(rpc, recoverTokenMint);
   const [userRecoveredTokenAccount] = await getProgramDerivedAddress7({
     programAddress: ASSOCIATED_TOKEN_PROGRAM_ADDRESS3,
@@ -7567,7 +7585,7 @@ async function cancelCrossChainOrderInstructions(orderAddress, options) {
   const userRecoveredTokenAccountInfo = await fetchEncodedAccount7(rpc, userRecoveredTokenAccount);
   if (!userRecoveredTokenAccountInfo.exists) {
     const createRecoveredTokenAccountIx = await getCreateAssociatedTokenInstructionAsync3({
-      payer: createNoopSigner4(orderUserAddress),
+      payer: createNoopSigner3(orderUserAddress),
       ata: userRecoveredTokenAccount,
       owner: orderUserAddress,
       mint: recoverTokenMint,
@@ -7578,7 +7596,7 @@ async function cancelCrossChainOrderInstructions(orderAddress, options) {
   let userCollateralTokenAccount;
   const willClaimCollateral = chainOrder.data.lockedCollateral > 0n;
   if (willClaimCollateral) {
-    const collateralTokenMint2 = address6(SOLANA_MINT_TOKEN.mint);
+    const collateralTokenMint2 = address5(SOLANA_MINT_TOKEN.mint);
     const collateralTokenMintProgram2 = await fetchMint3(rpc, collateralTokenMint2);
     const [userCollateralAccount] = await getProgramDerivedAddress7({
       programAddress: ASSOCIATED_TOKEN_PROGRAM_ADDRESS3,
@@ -7592,7 +7610,7 @@ async function cancelCrossChainOrderInstructions(orderAddress, options) {
     const userCollateralTokenAccountInfo = await fetchEncodedAccount7(rpc, userCollateralTokenAccount);
     if (!userCollateralTokenAccountInfo.exists) {
       const createCollateralTokenAccountIx = await getCreateAssociatedTokenInstructionAsync3({
-        payer: createNoopSigner4(orderUserAddress),
+        payer: createNoopSigner3(orderUserAddress),
         ata: userCollateralTokenAccount,
         owner: orderUserAddress,
         mint: collateralTokenMint2,
@@ -7601,7 +7619,7 @@ async function cancelCrossChainOrderInstructions(orderAddress, options) {
       instructions.push(createCollateralTokenAccountIx);
     }
   }
-  const collateralTokenMint = address6(SOLANA_MINT_TOKEN.mint);
+  const collateralTokenMint = address5(SOLANA_MINT_TOKEN.mint);
   const collateralTokenMintProgram = await fetchMint3(rpc, collateralTokenMint);
   const [guardCollateralTokenAccount] = await getProgramDerivedAddress7({
     programAddress: ASSOCIATED_TOKEN_PROGRAM_ADDRESS3,
@@ -7623,7 +7641,7 @@ async function cancelCrossChainOrderInstructions(orderAddress, options) {
     userCollateralTokenAccount,
     guardCollateralTokenAccount,
     collateralTokenProgram: collateralTokenMintProgram.programAddress,
-    signer: createNoopSigner4(orderUserAddress)
+    signer: createNoopSigner3(orderUserAddress)
   });
   instructions.push(cancelOrderIx);
   return instructions;
@@ -7634,8 +7652,8 @@ import { bytesToHex } from "viem";
 
 // src/core/solana/dca/cancel-order.ts
 import {
-  address as address7,
-  createNoopSigner as createNoopSigner5,
+  address as address6,
+  createNoopSigner as createNoopSigner4,
   createSolanaRpc as createSolanaRpc5,
   fetchEncodedAccount as fetchEncodedAccount8,
   getAddressEncoder as getAddressEncoder11,
@@ -7649,7 +7667,7 @@ import {
 } from "@solana-program/token";
 async function cancelDcaSingleChainOrderInstructions(orderAddress, options) {
   const rpc = options?.rpcUrl ? createSolanaRpc5(options.rpcUrl) : getDefaultSolanaRPC();
-  const orderId = address7(orderAddress);
+  const orderId = address6(orderAddress);
   const chainOrder = await fetchMaybeDcaOrder(rpc, orderId);
   if (!chainOrder.exists) {
     throw new Error(`Order with address ${orderAddress} not found`);
@@ -7684,14 +7702,14 @@ async function cancelDcaSingleChainOrderInstructions(orderAddress, options) {
     const createTokenIx = await getCreateAssociatedTokenInstructionAsync4({
       mint: tokenInMint,
       owner: orderUserAddress,
-      payer: createNoopSigner5(orderUserAddress),
+      payer: createNoopSigner4(orderUserAddress),
       tokenProgram: tokenMintProgram.programAddress
     });
     instructions.push(createTokenIx);
   }
   const cancelLimitOrderIx = getCancelDcaOrderInstruction({
     user: orderUserAddress,
-    signer: createNoopSigner5(orderUserAddress),
+    signer: createNoopSigner4(orderUserAddress),
     order: orderId,
     guard: guardAddress,
     tokenInMint: chainOrder.data.tokenInMint,
@@ -7735,7 +7753,7 @@ var SolanaSDK = class extends BaseSDK {
     const instructions = await cancelCrossChainOrderInstructions(orderId, { rpcUrl: this.config.rpcProviderUrl });
     const signer = await this.getUserSigner();
     const signerKeyPair = await this.getUserCryptoKeypair();
-    const noopSigner = createNoopSigner6(signer.address);
+    const noopSigner = createNoopSigner5(signer.address);
     const { value: latestBlockhash } = await this.client.rpc.getLatestBlockhash({ commitment: this.config.commitment }).send();
     const transactionMessage = pipe4(
       createTransactionMessage4({ version: 0 }),
@@ -7755,7 +7773,7 @@ var SolanaSDK = class extends BaseSDK {
     const instructions = await cancelSingleChainOrderInstructions(orderId, { rpcUrl: this.config.rpcProviderUrl });
     const signer = await this.getUserSigner();
     const signerKeyPair = await this.getUserCryptoKeypair();
-    const noopSigner = createNoopSigner6(signer.address);
+    const noopSigner = createNoopSigner5(signer.address);
     const { value: latestBlockhash } = await this.client.rpc.getLatestBlockhash({ commitment: this.config.commitment }).send();
     const transactionMessage = pipe4(
       createTransactionMessage4({ version: 0 }),
@@ -7806,7 +7824,7 @@ var SolanaSDK = class extends BaseSDK {
     const signableMessage = createSignableMessage(message);
     const signer = await this.getUserSigner();
     const signatureArray = await signer.signMessages([signableMessage]);
-    const signatureBytes = signatureArray.map((signature) => signature[address8(wallet)])[0];
+    const signatureBytes = signatureArray.map((signature) => signature[address7(wallet)])[0];
     if (!signatureBytes) {
       throw new Error("No signature bytes found");
     }
@@ -7869,7 +7887,7 @@ var SolanaSDK = class extends BaseSDK {
     const instructions = await cancelDcaSingleChainOrderInstructions(orderId, { rpcUrl: this.config.rpcProviderUrl });
     const signer = await this.getUserSigner();
     const signerKeyPair = await this.getUserCryptoKeypair();
-    const noopSigner = createNoopSigner6(signer.address);
+    const noopSigner = createNoopSigner5(signer.address);
     const { value: latestBlockhash } = await this.client.rpc.getLatestBlockhash({ commitment: this.config.commitment }).send();
     const transactionMessage = pipe4(
       createTransactionMessage4({ version: 0 }),
@@ -8043,31 +8061,6 @@ var SuiSDK = class extends BaseSDK {
   }
 };
 
-// src/core/orders/api/fetch.ts
-init_constants();
-async function fetchUserOrders(evmAddress, solAddress, suiAddress) {
-  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: withAuctioneerHeaders({ "Content-Type": "application/json" })
-  });
-  if (!response.ok) {
-    throw new Error(`Failed to fetch user orders: ${response.status} ${response.statusText}`);
-  }
-  const data = await response.json();
-  if (!data.success) {
-    throw new Error(`Failed to fetch user orders: ${data.error}`);
-  }
-  return data.data;
-}
-
 // src/core/orders/api/index.ts
 init_constants();
 var AuctioneerAPI = class {
@@ -8082,10 +8075,10 @@ var AuctioneerAPI = class {
     const url = `${AUCTIONEER_URL}/user_intent`;
     const response = await fetch(url, {
       method: "GET",
-      headers: withAuctioneerHeaders({
+      headers: {
         "Content-Type": "application/json",
         Authorization: `Bearer ${this.aggregatedToken}`
-      })
+      }
     });
     const data = await response.json();
     if (!data.success) {
@@ -8095,6 +8088,14 @@ var AuctioneerAPI = class {
   }
 };
 
+// src/core/orders/api/fetch.ts
+async function fetchUserOrders(aggregatedToken) {
+  if (!aggregatedToken) {
+    throw new Error("A SIWE-issued JWT is required to fetch user orders");
+  }
+  return new AuctioneerAPI(aggregatedToken).getUserOrders();
+}
+
 // src/index.ts
 init_errors();
 
@@ -8313,7 +8314,7 @@ function getInvalidateNoncesRawData(nonce) {
 }
 
 // src/core/solana/inspect.ts
-import { address as address9, createSolanaRpc as createSolanaRpc6 } from "@solana/kit";
+import { address as address8, createSolanaRpc as createSolanaRpc6 } from "@solana/kit";
 
 // src/utils/logger.ts
 init_errors();
@@ -8409,7 +8410,7 @@ var logger = Logger.getInstance();
 // src/core/solana/inspect.ts
 async function getSolanaOrdersWithLockedFunds(userAddress, config) {
   const rpc = config?.rpcUrl ? createSolanaRpc6(config.rpcUrl) : getDefaultSolanaRPC();
-  const programAccountAddress = address9("DQZQGiVa1PBXesdbCRzmJpZ7AyntLXfAwP5Qty1hgFqQ");
+  const programAccountAddress = address8("DQZQGiVa1PBXesdbCRzmJpZ7AyntLXfAwP5Qty1hgFqQ");
   const programAccountsConfig = {
     encoding: "base64",
     filters: [
@@ -8525,27 +8526,7 @@ init_single_chain_limit_order();
 
 // src/utils/generate-execution-details-hash.ts
 import { createHash } from "crypto";
-function generateExecutionDetailsHash({
-  destChainId,
-  destinationAddress,
-  tokenOut,
-  amountOutMin,
-  stopLossMaxOut,
-  takeProfitMinOut,
-  extraTransfers
-}) {
-  const executionDetails = JSON.stringify(
-    {
-      destChainId,
-      destinationAddress,
-      tokenOut,
-      amountOutMin,
-      stopLossMaxOut,
-      takeProfitMinOut,
-      extraTransfers
-    },
-    Parsers.bigIntReplacer
-  );
+function generateExecutionDetailsHash(executionDetails) {
   return "0x" + createHash("sha256").update(executionDetails).digest("hex");
 }
 
@@ -8563,7 +8544,9 @@ function createSuiSingleChainLimitOrderIntentRequest(params) {
     destinationAddress: params.destinationAddress,
     extraTransfers: params.extraTransfers,
     deadline: params.deadline,
-    takeProfitMinOut: params.takeProfitMinOut
+    takeProfitMinOut: params.takeProfitMinOut,
+    stopLossType: params.stopLossType,
+    stopLossTriggerPrice: params.stopLossTriggerPrice
   };
   return {
     genericData: order,
@@ -8613,7 +8596,7 @@ function createSuiCrossChainOrderIntentRequest(params) {
     extraTransfers: params.extraTransfers
   };
   const executionDetailsString = JSON.stringify(executionDetails, Parsers.bigIntReplacer);
-  const executionDetailsHash = generateExecutionDetailsHash(executionDetails);
+  const executionDetailsHash = generateExecutionDetailsHash(executionDetailsString);
   const genericData = {
     user: params.user,
     srcChainId: params.srcChainId,
@@ -8842,6 +8825,7 @@ async function getTokenList(params) {
 }
 
 // src/core/evm/intent-helpers.ts
+init_constants();
 function createEvmSingleChainLimitOrderIntentRequest(params) {
   const order = {
     user: params.user,
@@ -8862,7 +8846,7 @@ function createEvmSingleChainLimitOrderIntentRequest(params) {
     chainSpecificData: {
       EVM: {
         nonce: params.nonce || String(Math.floor(Math.random() * 1e7)),
-        signature: params.signature || "0x0000000000000000000000000000000000000000000000000000000000000000"
+        signature: params.signature || EVM_ZERO_SIGNATURE
       }
     }
   };
@@ -8887,7 +8871,7 @@ function createEvmSingleChainDcaOrderIntentRequest(params) {
     chainSpecificData: {
       EVM: {
         nonce: params.nonce || String(Math.floor(Math.random() * 1e7)),
-        signature: params.signature || "0x0000000000000000000000000000000000000000000000000000000000000000"
+        signature: params.signature || EVM_ZERO_SIGNATURE
       }
     }
   };
@@ -8904,7 +8888,7 @@ function createEvmCrossChainOrderIntentRequest(params) {
     stopLossTriggerPrice: params.stopLossTriggerPrice
   };
   const executionDetailsString = JSON.stringify(executionDetails, Parsers.bigIntReplacer);
-  const executionDetailsHash = generateExecutionDetailsHash(executionDetails);
+  const executionDetailsHash = generateExecutionDetailsHash(executionDetailsString);
   const genericData = {
     user: params.user,
     srcChainId: params.sourceChainId,
@@ -8913,10 +8897,7 @@ function createEvmCrossChainOrderIntentRequest(params) {
     minStablecoinsAmount: params.minStablecoinAmount || 1n,
     deadline: params.deadline,
     executionDetailsHash,
-    extraTransfers: params.extraTransfers,
-    takeProfitMinOut: params.takeProfitMinOut,
-    stopLossType: params.stopLossType,
-    stopLossTriggerPrice: params.stopLossTriggerPrice
+    extraTransfers: params.extraTransfers
   };
   return {
     genericData,
@@ -8924,7 +8905,7 @@ function createEvmCrossChainOrderIntentRequest(params) {
     chainSpecificData: {
       EVM: {
         nonce: params.nonce || String(Math.floor(Math.random() * 1e7)),
-        signature: params.signature || "0x0000000000000000000000000000000000000000000000000000000000000000"
+        signature: params.signature || EVM_ZERO_SIGNATURE
       }
     }
   };
@@ -8941,6 +8922,75 @@ async function generateEvmCrossChainOrderTypedData(order) {
 function generateEvmRandomNonce() {
   return String(Math.floor(Math.random() * 1e7));
 }
+function buildCrossChainDcaExecutionDetails(params) {
+  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) };
+}
+function createEvmCrossChainDcaOrderIntentRequest(params) {
+  const { executionDetailsString, executionDetailsHash } = buildCrossChainDcaExecutionDetails(params);
+  return {
+    genericData: {
+      user: params.user,
+      srcChainId: params.sourceChainId,
+      tokenIn: params.sourceTokenAddress,
+      minStablecoinsAmount: params.minStablecoinAmount || 1n,
+      deadline: params.deadline,
+      executionDetailsHash,
+      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
+      }
+    }
+  };
+}
+function getEVMCrossChainDcaOrderTypedData(params, providedNonce) {
+  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];
+  const message = {
+    permitted: { token: params.sourceTokenAddress, amount: totalAmountIn },
+    spender,
+    nonce,
+    deadline: BigInt(params.deadline),
+    witness: {
+      user: params.user,
+      tokenIn: params.sourceTokenAddress,
+      srcChainId: params.sourceChainId,
+      startTime: params.startTime,
+      deadline: params.deadline,
+      totalIntervals: params.totalIntervals,
+      intervalDuration: params.intervalDuration,
+      amountInPerInterval: params.amountInPerInterval,
+      minStablecoinsAmountPerInterval: params.minStablecoinAmount || 1n,
+      executionDetailsHash,
+      nonce
+    }
+  };
+  return {
+    orderTypedData: {
+      domain: PERMIT2_DOMAIN(params.sourceChainId),
+      types: CROSS_CHAIN_DCA_PERMIT2_TYPES,
+      primaryType: "PermitWitnessTransferFrom",
+      message
+    },
+    nonce
+  };
+}
 
 // src/core/solana/intent-helpers.ts
 function createSolanaSingleChainLimitOrderIntentRequest(params) {
@@ -9002,11 +9052,12 @@ function createSolanaCrossChainOrderIntentRequest(params) {
     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);
-  const executionDetailsHash = generateExecutionDetailsHash(executionDetails);
+  const executionDetailsHash = generateExecutionDetailsHash(executionDetailsString);
   const genericData = {
     user: params.user,
     srcChainId: params.sourceChainId,
@@ -9027,14 +9078,14 @@ function createSolanaCrossChainOrderIntentRequest(params) {
     }
   };
 }
-async function generateSolanaSingleChainLimitOrderInstructions(order, options) {
-  return getSolanaSingleChainOrderInstructions(order, options);
+async function generateSolanaSingleChainLimitOrderInstructions(order) {
+  return getSolanaSingleChainOrderInstructions(order);
 }
-async function generateSolanaSingleChainDcaOrderInstructions(order, options) {
-  return getSolanaDcaSingleChainOrderInstructions(order, options);
+async function generateSolanaSingleChainDcaOrderInstructions(order) {
+  return getSolanaDcaSingleChainOrderInstructions(order);
 }
-async function generateSolanaCrossChainOrderInstructions(order, options) {
-  return getSolanaCrossChainOrderInstructions(order, options);
+async function generateSolanaCrossChainOrderInstructions(order) {
+  return getSolanaCrossChainOrderInstructions(order);
 }
 function generateSolanaLimitOrderSecretData(tokenOut, receiver, secretNumber, extraTransfers) {
   const secret = secretNumber || generateSolanaRandomSecretNumber();
@@ -9080,11 +9131,12 @@ export {
   ChainID,
   ChainType,
   CrossChainOrder,
+  DCA_CROSS_CHAIN_GUARD_ADDRESSES,
   DCA_SINGLE_CHAIN_GUARD_ADDRESSES,
-  DEV_ACCESS_HEADER,
-  DEV_ACCESS_STORAGE_KEY,
   DcaSingleChainOrder,
   EVMSDK,
+  EVM_ZERO_ADDRESS,
+  EVM_ZERO_SIGNATURE,
   IntentsOrderType,
   MAX_UINT_128,
   MAX_UINT_256,
@@ -9102,8 +9154,6 @@ export {
   QuoteProvider,
   SINGLE_CHAIN_GUARD_ADDRESSES,
   SOLANA_MINT_TOKEN,
-  SOLANA_MIN_TIP_LAMPORTS,
-  SOLANA_TIP_ACCOUNTS,
   SOLANA_USDC_MINT,
   SUI_GUARD_COLLATERAL_TYPE,
   SUI_GUARD_STABLECOIN_TYPE,
@@ -9125,6 +9175,7 @@ export {
   cancelDcaSingleChainOrderInstructions,
   cancelSingleChainOrderInstructionsAsBytes,
   chainIdToChainTypeMap,
+  createEvmCrossChainDcaOrderIntentRequest,
   createEvmCrossChainOrderIntentRequest,
   createEvmSingleChainDcaOrderIntentRequest,
   createEvmSingleChainLimitOrderIntentRequest,
@@ -9154,7 +9205,7 @@ export {
   getCancelSingleChainOrderRawData,
   getCoinFromResponse,
   getDcaSecretHash,
-  getDevAccessHeaderValue,
+  getEVMCrossChainDcaOrderTypedData,
   getEVMCrossChainOrderTypedData,
   getEVMSingleChainOrderTypedData,
   getInvalidateNoncesRawData,
@@ -9175,10 +9226,10 @@ export {
   isNativeEvmToken,
   isSuccessApiResponse,
   isSupportedChain,
+  normalizeNativeEvmTokenForSigning,
   prepareDcaSecretData,
   prepareSecretData,
   signSingleChainDcaOrder,
-  signSingleChainLimitOrder,
-  withAuctioneerHeaders
+  signSingleChainLimitOrder
 };
 //# sourceMappingURL=index.js.map