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

package/dist/index.cjs

@@ -144,7 +144,10 @@ function isNativeEvmToken(tokenAddress) {
   const normalizedAddress = tokenAddress.toLowerCase();
   return NATIVE_EVM_ETH_ADDRESSES.some((addr) => addr.toLowerCase() === normalizedAddress);
 }
-var import_kit, 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 import_kit, 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";
@@ -205,7 +208,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"
     };
@@ -228,21 +233,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",
@@ -254,7 +247,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;
@@ -272,6 +266,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";
   }
 });
@@ -387,11 +383,12 @@ __export(index_exports, {
   ChainID: () => ChainID,
   ChainType: () => ChainType,
   CrossChainOrder: () => CrossChainOrder,
+  DCA_CROSS_CHAIN_GUARD_ADDRESSES: () => DCA_CROSS_CHAIN_GUARD_ADDRESSES,
   DCA_SINGLE_CHAIN_GUARD_ADDRESSES: () => DCA_SINGLE_CHAIN_GUARD_ADDRESSES,
-  DEV_ACCESS_HEADER: () => DEV_ACCESS_HEADER,
-  DEV_ACCESS_STORAGE_KEY: () => DEV_ACCESS_STORAGE_KEY,
   DcaSingleChainOrder: () => DcaSingleChainOrder,
   EVMSDK: () => EVMSDK,
+  EVM_ZERO_ADDRESS: () => EVM_ZERO_ADDRESS,
+  EVM_ZERO_SIGNATURE: () => EVM_ZERO_SIGNATURE,
   IntentsOrderType: () => IntentsOrderType,
   MAX_UINT_128: () => MAX_UINT_128,
   MAX_UINT_256: () => MAX_UINT_256,
@@ -409,8 +406,6 @@ __export(index_exports, {
   QuoteProvider: () => QuoteProvider,
   SINGLE_CHAIN_GUARD_ADDRESSES: () => SINGLE_CHAIN_GUARD_ADDRESSES,
   SOLANA_MINT_TOKEN: () => SOLANA_MINT_TOKEN,
-  SOLANA_MIN_TIP_LAMPORTS: () => SOLANA_MIN_TIP_LAMPORTS,
-  SOLANA_TIP_ACCOUNTS: () => SOLANA_TIP_ACCOUNTS,
   SOLANA_USDC_MINT: () => SOLANA_USDC_MINT,
   SUI_GUARD_COLLATERAL_TYPE: () => SUI_GUARD_COLLATERAL_TYPE,
   SUI_GUARD_STABLECOIN_TYPE: () => SUI_GUARD_STABLECOIN_TYPE,
@@ -432,6 +427,7 @@ __export(index_exports, {
   cancelDcaSingleChainOrderInstructions: () => cancelDcaSingleChainOrderInstructions,
   cancelSingleChainOrderInstructionsAsBytes: () => cancelSingleChainOrderInstructionsAsBytes,
   chainIdToChainTypeMap: () => chainIdToChainTypeMap,
+  createEvmCrossChainDcaOrderIntentRequest: () => createEvmCrossChainDcaOrderIntentRequest,
   createEvmCrossChainOrderIntentRequest: () => createEvmCrossChainOrderIntentRequest,
   createEvmSingleChainDcaOrderIntentRequest: () => createEvmSingleChainDcaOrderIntentRequest,
   createEvmSingleChainLimitOrderIntentRequest: () => createEvmSingleChainLimitOrderIntentRequest,
@@ -461,7 +457,7 @@ __export(index_exports, {
   getCancelSingleChainOrderRawData: () => getCancelSingleChainOrderRawData,
   getCoinFromResponse: () => getCoinFromResponse,
   getDcaSecretHash: () => getDcaSecretHash,
-  getDevAccessHeaderValue: () => getDevAccessHeaderValue,
+  getEVMCrossChainDcaOrderTypedData: () => getEVMCrossChainDcaOrderTypedData,
   getEVMCrossChainOrderTypedData: () => getEVMCrossChainOrderTypedData,
   getEVMSingleChainOrderTypedData: () => getEVMSingleChainOrderTypedData,
   getInvalidateNoncesRawData: () => getInvalidateNoncesRawData,
@@ -482,11 +478,11 @@ __export(index_exports, {
   isNativeEvmToken: () => isNativeEvmToken,
   isSuccessApiResponse: () => isSuccessApiResponse,
   isSupportedChain: () => isSupportedChain,
+  normalizeNativeEvmTokenForSigning: () => normalizeNativeEvmTokenForSigning,
   prepareDcaSecretData: () => prepareDcaSecretData,
   prepareSecretData: () => prepareSecretData,
   signSingleChainDcaOrder: () => signSingleChainDcaOrder,
-  signSingleChainLimitOrder: () => signSingleChainLimitOrder,
-  withAuctioneerHeaders: () => withAuctioneerHeaders
+  signSingleChainLimitOrder: () => signSingleChainLimitOrder
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -519,9 +515,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);
     }
@@ -571,9 +564,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) {
@@ -3298,9 +3291,9 @@ var ChainProvider = class _ChainProvider {
       }
     });
   }
-  getSingleChainAuctioneerContract(address10) {
+  getSingleChainAuctioneerContract(address9) {
     return (0, import_viem3.getContract)({
-      address: address10,
+      address: address9,
       abi: SINGLE_CHAIN_GUARD_LIMIT_ABI,
       client: {
         wallet: this.walletClient,
@@ -3339,8 +3332,8 @@ var ChainProvider = class _ChainProvider {
 
 // src/core/evm/validator.ts
 var EvmValidator = class extends BaseValidator {
-  isValidAddress(address10) {
-    return (0, import_viem4.isAddress)(address10);
+  isValidAddress(address9) {
+    return (0, import_viem4.isAddress)(address9);
   }
   isValidTokenAddress(tokenAddress) {
     return (0, import_viem4.isAddress)(tokenAddress);
@@ -3437,8 +3430,8 @@ var SolanaValidator = class extends BaseValidator {
   validateSingleChainOrderFeasability() {
     return Promise.resolve();
   }
-  isValidAddress(address10) {
-    return (0, import_kit2.isAddress)(address10);
+  isValidAddress(address9) {
+    return (0, import_kit2.isAddress)(address9);
   }
   isValidTokenAddress(tokenAddress) {
     return (0, import_kit2.isAddress)(tokenAddress);
@@ -3462,12 +3455,12 @@ var import_utils = require("@mysten/sui/utils");
 init_constants();
 var SUI_TOKEN_ADDRESS_REGEX = /^0x[a-fA-F0-9]{64}::\w+::\w+$/;
 var SuiValidator = class extends BaseValidator {
-  isValidAddress(address10) {
-    return (0, import_utils.isValidSuiAddress)((0, import_utils.normalizeSuiAddress)(address10));
+  isValidAddress(address9) {
+    return (0, import_utils.isValidSuiAddress)((0, import_utils.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) {
@@ -3574,35 +3567,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
 var import_viem5 = require("viem");
 var Parsers;
@@ -3720,6 +3684,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 {
@@ -3786,12 +3773,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
     })) || [];
@@ -3839,12 +3826,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
     })) || [];
@@ -3913,7 +3900,7 @@ async function getEVMDcaSingleChainOrderTypedData(order) {
 // src/core/solana/order-instructions.ts
 var import_system = require("@solana-program/system");
 var import_token = require("@solana-program/token");
-var import_kit5 = require("@solana/kit");
+var import_kit4 = require("@solana/kit");
 init_constants();
 
 // src/core/solana/client.ts
@@ -3962,8 +3949,8 @@ function getOrderDecoder() {
 function decodeOrder(encodedAccount) {
   return (0, import_accounts2.decodeAccount)(encodedAccount, getOrderDecoder());
 }
-async function fetchMaybeOrder(rpc, address10, config) {
-  const maybeAccount = await (0, import_accounts2.fetchEncodedAccount)(rpc, address10, config);
+async function fetchMaybeOrder(rpc, address9, config) {
+  const maybeAccount = await (0, import_accounts2.fetchEncodedAccount)(rpc, address9, config);
   return decodeOrder(maybeAccount);
 }
 
@@ -4152,8 +4139,8 @@ function getDcaOrderDecoder() {
 function decodeDcaOrder(encodedAccount) {
   return (0, import_accounts3.decodeAccount)(encodedAccount, getDcaOrderDecoder());
 }
-async function fetchMaybeDcaOrder(rpc, address10, config) {
-  const maybeAccount = await (0, import_accounts3.fetchEncodedAccount)(rpc, address10, config);
+async function fetchMaybeDcaOrder(rpc, address9, config) {
+  const maybeAccount = await (0, import_accounts3.fetchEncodedAccount)(rpc, address9, config);
   return decodeDcaOrder(maybeAccount);
 }
 
@@ -4178,8 +4165,8 @@ function getLimitOrderDecoder() {
 function decodeLimitOrder(encodedAccount) {
   return (0, import_accounts4.decodeAccount)(encodedAccount, getLimitOrderDecoder());
 }
-async function fetchMaybeLimitOrder(rpc, address10, config) {
-  const maybeAccount = await (0, import_accounts4.fetchEncodedAccount)(rpc, address10, config);
+async function fetchMaybeLimitOrder(rpc, address9, config) {
+  const maybeAccount = await (0, import_accounts4.fetchEncodedAccount)(rpc, address9, config);
   return decodeLimitOrder(maybeAccount);
 }
 
@@ -4503,80 +4490,23 @@ function formatTokenPubkey(token) {
   return token;
 }
 
-// src/core/solana/transaction-options.ts
-var import_kit4 = require("@solana/kit");
-init_constants();
-function resolveSolanaFeePayer(userSigner, feePayer) {
-  if (!feePayer || feePayer === userSigner.address) {
-    return userSigner;
-  }
-  const feePayerAddress = (0, import_kit4.address)(feePayer);
-  return (0, import_kit4.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: (0, import_kit4.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 ? (0, import_kit5.createSolanaRpc)(options.rpcUrl) : getDefaultSolanaRPC();
-  const orderSigner = await (0, import_kit5.generateKeyPairSigner)();
-  const userSigner = (0, import_kit5.createNoopSigner)(order.user);
-  const feePayerSigner = resolveSolanaFeePayer(userSigner, options?.feePayer);
-  let tokenInMint = (0, import_kit5.address)(order.tokenIn);
+  const rpc = options?.rpcUrl ? (0, import_kit4.createSolanaRpc)(options.rpcUrl) : getDefaultSolanaRPC();
+  const orderSigner = await (0, import_kit4.generateKeyPairSigner)();
+  const signer = (0, import_kit4.createNoopSigner)(order.user);
+  let tokenInMint = (0, import_kit4.address)(order.tokenIn);
   const { secretHash, secretNumber } = genSecretHashAndNumber(order);
-  const orderUserAddress = (0, import_kit5.address)(order.user);
+  const orderUserAddress = (0, import_kit4.address)(order.user);
   const spendingNative = tokenInMint === NATIVE_SOLANA_TOKEN_ADDRESS;
   if (spendingNative) {
     tokenInMint = WRAPPED_SOL_MINT_ADDRESS;
   }
   const tokenMintProgram = await (0, import_token.fetchMint)(rpc, tokenInMint);
-  const guardAddress = (0, import_kit5.address)(SINGLE_CHAIN_GUARD_ADDRESSES[7565164 /* Solana */]);
-  const addressEncoder = (0, import_kit5.getAddressEncoder)();
+  const guardAddress = (0, import_kit4.address)(SINGLE_CHAIN_GUARD_ADDRESSES[7565164 /* Solana */]);
+  const addressEncoder = (0, import_kit4.getAddressEncoder)();
   const instructions = [];
-  const [tokenInProgramAccount] = await (0, import_kit5.getProgramDerivedAddress)({
+  const [tokenInProgramAccount] = await (0, import_kit4.getProgramDerivedAddress)({
     programAddress: import_token.ASSOCIATED_TOKEN_PROGRAM_ADDRESS,
     seeds: [
       addressEncoder.encode(orderUserAddress),
@@ -4584,10 +4514,10 @@ async function getSolanaSingleChainOrderInstructions(order, options) {
       addressEncoder.encode(tokenInMint)
     ]
   });
-  const userTokenInAccount = await (0, import_kit5.fetchEncodedAccount)(rpc, tokenInProgramAccount);
+  const userTokenInAccount = await (0, import_kit4.fetchEncodedAccount)(rpc, tokenInProgramAccount);
   if (!userTokenInAccount.exists) {
     const createAccountIx = await (0, import_token.getCreateAssociatedTokenInstructionAsync)({
-      payer: feePayerSigner,
+      payer: signer,
       ata: tokenInProgramAccount,
       owner: orderUserAddress,
       mint: tokenMintProgram.address,
@@ -4599,7 +4529,7 @@ async function getSolanaSingleChainOrderInstructions(order, options) {
     const transferIx = (0, import_system.getTransferSolInstruction)({
       amount: order.amountIn,
       destination: userTokenInAccount.address,
-      source: userSigner
+      source: signer
     });
     instructions.push(transferIx);
     const syncNativeIx = (0, import_token.getSyncNativeInstruction)({
@@ -4608,7 +4538,7 @@ async function getSolanaSingleChainOrderInstructions(order, options) {
     instructions.push(syncNativeIx);
   }
   const createSingleChainLimitOrderIx = await getCreateLimitOrderInstructionAsync({
-    user: userSigner,
+    user: signer,
     order: orderSigner,
     guard: guardAddress,
     tokenInMint,
@@ -4622,26 +4552,16 @@ async function getSolanaSingleChainOrderInstructions(order, options) {
     // TODO
   });
   instructions.push(createSingleChainLimitOrderIx);
-  const tip = resolveSolanaTip(options);
-  if (tip) {
-    instructions.push(
-      (0, import_system.getTransferSolInstruction)({
-        source: feePayerSigner,
-        destination: tip.account,
-        amount: tip.lamports
-      })
-    );
-  }
   const { value: latestBlockhash } = await rpc.getLatestBlockhash({ commitment: "confirmed" }).send();
-  const txMessage = (0, import_kit5.pipe)(
-    (0, import_kit5.createTransactionMessage)({ version: 0 }),
-    (tx) => (0, import_kit5.setTransactionMessageFeePayerSigner)(feePayerSigner, tx),
-    (tx) => (0, import_kit5.setTransactionMessageLifetimeUsingBlockhash)(latestBlockhash, tx),
-    (tx) => (0, import_kit5.appendTransactionMessageInstructions)(instructions, tx),
-    (tx) => (0, import_kit5.addSignersToTransactionMessage)([orderSigner], tx)
+  const txMessage = (0, import_kit4.pipe)(
+    (0, import_kit4.createTransactionMessage)({ version: 0 }),
+    (tx) => (0, import_kit4.setTransactionMessageFeePayerSigner)(signer, tx),
+    (tx) => (0, import_kit4.setTransactionMessageLifetimeUsingBlockhash)(latestBlockhash, tx),
+    (tx) => (0, import_kit4.appendTransactionMessageInstructions)(instructions, tx),
+    (tx) => (0, import_kit4.addSignersToTransactionMessage)([orderSigner], tx)
   );
-  const partiallySignedTransaction = await (0, import_kit5.partiallySignTransactionMessageWithSigners)(txMessage);
-  const txBytes = (0, import_kit5.getTransactionCodec)().encode(partiallySignedTransaction);
+  const partiallySignedTransaction = await (0, import_kit4.partiallySignTransactionMessageWithSigners)(txMessage);
+  const txBytes = (0, import_kit4.getTransactionCodec)().encode(partiallySignedTransaction);
   return {
     orderAddress: orderSigner.address,
     txBytes,
@@ -4649,20 +4569,19 @@ async function getSolanaSingleChainOrderInstructions(order, options) {
   };
 }
 async function getSolanaCrossChainOrderInstructions(order, options) {
-  const rpc = options?.rpcUrl ? (0, import_kit5.createSolanaRpc)(options.rpcUrl) : getDefaultSolanaRPC();
-  const orderSigner = await (0, import_kit5.generateKeyPairSigner)();
-  const userSigner = (0, import_kit5.createNoopSigner)(order.user);
-  const feePayerSigner = resolveSolanaFeePayer(userSigner, options?.feePayer);
-  let tokenInMint = (0, import_kit5.address)(order.sourceTokenAddress);
-  const orderUserAddress = (0, import_kit5.address)(order.user);
+  const rpc = options?.rpcUrl ? (0, import_kit4.createSolanaRpc)(options.rpcUrl) : getDefaultSolanaRPC();
+  const orderSigner = await (0, import_kit4.generateKeyPairSigner)();
+  const signer = (0, import_kit4.createNoopSigner)(order.user);
+  let tokenInMint = (0, import_kit4.address)(order.sourceTokenAddress);
+  const orderUserAddress = (0, import_kit4.address)(order.user);
   const spendingNative = tokenInMint === NATIVE_SOLANA_TOKEN_ADDRESS;
   if (spendingNative) {
     tokenInMint = WRAPPED_SOL_MINT_ADDRESS;
   }
   const tokenMintProgram = await (0, import_token.fetchMint)(rpc, tokenInMint);
-  const guardAddress = (0, import_kit5.address)(CROSS_CHAIN_GUARD_ADDRESSES[7565164 /* Solana */]);
-  const addressEncoder = (0, import_kit5.getAddressEncoder)();
-  const [tokenInProgramAccount] = await (0, import_kit5.getProgramDerivedAddress)({
+  const guardAddress = (0, import_kit4.address)(CROSS_CHAIN_GUARD_ADDRESSES[7565164 /* Solana */]);
+  const addressEncoder = (0, import_kit4.getAddressEncoder)();
+  const [tokenInProgramAccount] = await (0, import_kit4.getProgramDerivedAddress)({
     programAddress: import_token.ASSOCIATED_TOKEN_PROGRAM_ADDRESS,
     seeds: [
       addressEncoder.encode(orderUserAddress),
@@ -4670,7 +4589,7 @@ async function getSolanaCrossChainOrderInstructions(order, options) {
       addressEncoder.encode(tokenInMint)
     ]
   });
-  const [guardProgramAccount] = await (0, import_kit5.getProgramDerivedAddress)({
+  const [guardProgramAccount] = await (0, import_kit4.getProgramDerivedAddress)({
     programAddress: import_token.ASSOCIATED_TOKEN_PROGRAM_ADDRESS,
     seeds: [
       // Owner
@@ -4682,12 +4601,12 @@ async function getSolanaCrossChainOrderInstructions(order, options) {
     ]
   });
   const instructions = [];
-  const userTokenInAccount = await (0, import_kit5.fetchEncodedAccount)(rpc, tokenInProgramAccount);
+  const userTokenInAccount = await (0, import_kit4.fetchEncodedAccount)(rpc, tokenInProgramAccount);
   if (spendingNative) {
     order.sourceTokenAddress = WRAPPED_SOL_MINT_ADDRESS;
     if (!userTokenInAccount.exists) {
       const createAccountIx = await (0, import_token.getCreateAssociatedTokenInstructionAsync)({
-        payer: feePayerSigner,
+        payer: signer,
         ata: tokenInProgramAccount,
         owner: orderUserAddress,
         mint: tokenMintProgram.address,
@@ -4696,7 +4615,7 @@ async function getSolanaCrossChainOrderInstructions(order, options) {
       instructions.push(createAccountIx);
     }
     const transferIx = (0, import_system.getTransferSolInstruction)({
-      source: userSigner,
+      source: signer,
       destination: userTokenInAccount.address,
       amount: order.sourceTokenAmount
     });
@@ -4708,9 +4627,9 @@ async function getSolanaCrossChainOrderInstructions(order, options) {
   }
   const executionHashUint8Array = order.executionDetailsHashToBytes();
   const createOrderIx = getCreateOrderInstruction({
-    user: userSigner,
+    user: signer,
     order: orderSigner,
-    guard: (0, import_kit5.address)(CROSS_CHAIN_GUARD_ADDRESSES[7565164 /* Solana */]),
+    guard: (0, import_kit4.address)(CROSS_CHAIN_GUARD_ADDRESSES[7565164 /* Solana */]),
     systemProgram: import_system.SYSTEM_PROGRAM_ADDRESS,
     associatedTokenProgram: import_token.ASSOCIATED_TOKEN_PROGRAM_ADDRESS,
     tokenInMint,
@@ -4723,26 +4642,16 @@ async function getSolanaCrossChainOrderInstructions(order, options) {
     minStablecoinsAmount: order.minStablecoinAmount
   });
   instructions.push(createOrderIx);
-  const tip = resolveSolanaTip(options);
-  if (tip) {
-    instructions.push(
-      (0, import_system.getTransferSolInstruction)({
-        source: feePayerSigner,
-        destination: tip.account,
-        amount: tip.lamports
-      })
-    );
-  }
   const { value: latestBlockhash } = await rpc.getLatestBlockhash({ commitment: "confirmed" }).send();
-  const txMessage = (0, import_kit5.pipe)(
-    (0, import_kit5.createTransactionMessage)({ version: 0 }),
-    (tx) => (0, import_kit5.setTransactionMessageFeePayerSigner)(feePayerSigner, tx),
-    (tx) => (0, import_kit5.setTransactionMessageLifetimeUsingBlockhash)(latestBlockhash, tx),
-    (tx) => (0, import_kit5.appendTransactionMessageInstructions)(instructions, tx),
-    (tx) => (0, import_kit5.addSignersToTransactionMessage)([orderSigner], tx)
+  const txMessage = (0, import_kit4.pipe)(
+    (0, import_kit4.createTransactionMessage)({ version: 0 }),
+    (tx) => (0, import_kit4.setTransactionMessageFeePayerSigner)(signer, tx),
+    (tx) => (0, import_kit4.setTransactionMessageLifetimeUsingBlockhash)(latestBlockhash, tx),
+    (tx) => (0, import_kit4.appendTransactionMessageInstructions)(instructions, tx),
+    (tx) => (0, import_kit4.addSignersToTransactionMessage)([orderSigner], tx)
   );
-  const partiallySignedTransaction = await (0, import_kit5.partiallySignTransactionMessageWithSigners)(txMessage);
-  const txBytes = (0, import_kit5.getTransactionCodec)().encode(partiallySignedTransaction);
+  const partiallySignedTransaction = await (0, import_kit4.partiallySignTransactionMessageWithSigners)(txMessage);
+  const txBytes = (0, import_kit4.getTransactionCodec)().encode(partiallySignedTransaction);
   return {
     orderAddress: orderSigner.address,
     txBytes: Uint8Array.from(txBytes)
@@ -5336,113 +5245,113 @@ var RaydiumQuoteProvider = class {
 };
 
 // src/utils/quote/pumpfun/index.ts
-var import_kit8 = require("@solana/kit");
+var import_kit7 = require("@solana/kit");
 
 // src/utils/quote/pumpfun/utils.ts
-var import_kit7 = require("@solana/kit");
+var import_kit6 = require("@solana/kit");
 
 // src/utils/quote/pumpfun/models.ts
-var import_kit6 = require("@solana/kit");
+var import_kit5 = require("@solana/kit");
 function getPumpPoolDataDecoder() {
-  return (0, import_kit6.getStructDecoder)([
-    ["poolBump", (0, import_kit6.getU8Decoder)()],
-    ["index", (0, import_kit6.getU16Decoder)()],
-    ["creator", (0, import_kit6.getAddressDecoder)()],
-    ["baseMint", (0, import_kit6.getAddressDecoder)()],
-    ["quoteMint", (0, import_kit6.getAddressDecoder)()],
-    ["lpMint", (0, import_kit6.getAddressDecoder)()],
-    ["poolBaseTokenAccount", (0, import_kit6.getAddressDecoder)()],
-    ["poolQuoteTokenAccount", (0, import_kit6.getAddressDecoder)()],
-    ["lpSupply", (0, import_kit6.getU64Decoder)()],
-    ["coinCreator", (0, import_kit6.getAddressDecoder)()]
+  return (0, import_kit5.getStructDecoder)([
+    ["poolBump", (0, import_kit5.getU8Decoder)()],
+    ["index", (0, import_kit5.getU16Decoder)()],
+    ["creator", (0, import_kit5.getAddressDecoder)()],
+    ["baseMint", (0, import_kit5.getAddressDecoder)()],
+    ["quoteMint", (0, import_kit5.getAddressDecoder)()],
+    ["lpMint", (0, import_kit5.getAddressDecoder)()],
+    ["poolBaseTokenAccount", (0, import_kit5.getAddressDecoder)()],
+    ["poolQuoteTokenAccount", (0, import_kit5.getAddressDecoder)()],
+    ["lpSupply", (0, import_kit5.getU64Decoder)()],
+    ["coinCreator", (0, import_kit5.getAddressDecoder)()]
   ]);
 }
 function getBondingCurveDecoder() {
-  return (0, import_kit6.getStructDecoder)([
-    ["virtualTokenReserves", (0, import_kit6.getU64Decoder)()],
-    ["virtualSolReserves", (0, import_kit6.getU64Decoder)()],
-    ["realTokenReserves", (0, import_kit6.getU64Decoder)()],
-    ["realSolReserves", (0, import_kit6.getU64Decoder)()],
-    ["tokenTotalSupply", (0, import_kit6.getU64Decoder)()],
-    ["complete", (0, import_kit6.getBooleanDecoder)()],
-    ["creator", (0, import_kit6.getAddressDecoder)()]
+  return (0, import_kit5.getStructDecoder)([
+    ["virtualTokenReserves", (0, import_kit5.getU64Decoder)()],
+    ["virtualSolReserves", (0, import_kit5.getU64Decoder)()],
+    ["realTokenReserves", (0, import_kit5.getU64Decoder)()],
+    ["realSolReserves", (0, import_kit5.getU64Decoder)()],
+    ["tokenTotalSupply", (0, import_kit5.getU64Decoder)()],
+    ["complete", (0, import_kit5.getBooleanDecoder)()],
+    ["creator", (0, import_kit5.getAddressDecoder)()]
   ]);
 }
 function getGlobalAccountDecoder() {
-  return (0, import_kit6.getStructDecoder)([
-    ["initialized", (0, import_kit6.getBooleanDecoder)()],
-    ["authority", (0, import_kit6.getAddressDecoder)()],
-    ["feeRecipient", (0, import_kit6.getAddressDecoder)()],
-    ["initialVirtualTokenReserves", (0, import_kit6.getU64Decoder)()],
-    ["initialVirtualSolReserves", (0, import_kit6.getU64Decoder)()],
-    ["initialRealTokenReserves", (0, import_kit6.getU64Decoder)()],
-    ["tokenTotalSupply", (0, import_kit6.getU64Decoder)()],
-    ["feeBasisPoints", (0, import_kit6.getU64Decoder)()],
-    ["withdrawAuthority", (0, import_kit6.getAddressDecoder)()],
-    ["enableMigrate", (0, import_kit6.getBooleanDecoder)()],
-    ["poolMigrationFee", (0, import_kit6.getU64Decoder)()],
-    ["creatorFeeBasisPoints", (0, import_kit6.getU64Decoder)()],
-    ["feeRecipients", (0, import_kit6.getArrayDecoder)((0, import_kit6.getAddressDecoder)(), { size: 7 })],
+  return (0, import_kit5.getStructDecoder)([
+    ["initialized", (0, import_kit5.getBooleanDecoder)()],
+    ["authority", (0, import_kit5.getAddressDecoder)()],
+    ["feeRecipient", (0, import_kit5.getAddressDecoder)()],
+    ["initialVirtualTokenReserves", (0, import_kit5.getU64Decoder)()],
+    ["initialVirtualSolReserves", (0, import_kit5.getU64Decoder)()],
+    ["initialRealTokenReserves", (0, import_kit5.getU64Decoder)()],
+    ["tokenTotalSupply", (0, import_kit5.getU64Decoder)()],
+    ["feeBasisPoints", (0, import_kit5.getU64Decoder)()],
+    ["withdrawAuthority", (0, import_kit5.getAddressDecoder)()],
+    ["enableMigrate", (0, import_kit5.getBooleanDecoder)()],
+    ["poolMigrationFee", (0, import_kit5.getU64Decoder)()],
+    ["creatorFeeBasisPoints", (0, import_kit5.getU64Decoder)()],
+    ["feeRecipients", (0, import_kit5.getArrayDecoder)((0, import_kit5.getAddressDecoder)(), { size: 7 })],
     // Fixed array of 7 Pubkeys
-    ["setCreatorAuthority", (0, import_kit6.getAddressDecoder)()],
-    ["adminSetCreatorAuthority", (0, import_kit6.getAddressDecoder)()]
+    ["setCreatorAuthority", (0, import_kit5.getAddressDecoder)()],
+    ["adminSetCreatorAuthority", (0, import_kit5.getAddressDecoder)()]
   ]);
 }
 function getGlobalConfigDecoder() {
-  return (0, import_kit6.getStructDecoder)([
-    ["admin", (0, import_kit6.getAddressDecoder)()],
-    ["lpFeeBasisPoints", (0, import_kit6.getU64Decoder)()],
-    ["protocolFeeBasisPoints", (0, import_kit6.getU64Decoder)()],
-    ["disableFlags", (0, import_kit6.getU8Decoder)()],
-    ["protocolFeeRecipients", (0, import_kit6.getArrayDecoder)((0, import_kit6.getAddressDecoder)(), { size: 8 })],
+  return (0, import_kit5.getStructDecoder)([
+    ["admin", (0, import_kit5.getAddressDecoder)()],
+    ["lpFeeBasisPoints", (0, import_kit5.getU64Decoder)()],
+    ["protocolFeeBasisPoints", (0, import_kit5.getU64Decoder)()],
+    ["disableFlags", (0, import_kit5.getU8Decoder)()],
+    ["protocolFeeRecipients", (0, import_kit5.getArrayDecoder)((0, import_kit5.getAddressDecoder)(), { size: 8 })],
     // Fixed array of 8 Pubkeys
-    ["coinCreatorFeeBasisPoints", (0, import_kit6.getU64Decoder)()],
-    ["adminSetCoinCreatorAuthority", (0, import_kit6.getAddressDecoder)()]
+    ["coinCreatorFeeBasisPoints", (0, import_kit5.getU64Decoder)()],
+    ["adminSetCoinCreatorAuthority", (0, import_kit5.getAddressDecoder)()]
   ]);
 }
 
 // src/utils/quote/pumpfun/utils.ts
 var import_token2 = require("@solana-program/token");
-var PUMP_FUN_PROGRAM_ADDRESS = (0, import_kit7.address)("6EF8rrecthR5Dkzon8Nwu78hRvfCKubJ14M5uBEwF6P");
-var PUMP_FUN_AMM_PROGRAM_ADDRESS = (0, import_kit7.address)("pAMMBay6oceH9fJKBRHGP5D4bD4sWpmSwMn52FMfXEA");
-var WRAPPED_NATIVE_TOKEN_PUBKEY = (0, import_kit7.address)("So11111111111111111111111111111111111111112");
-var GLOBAL_CONFIG_AMM = (0, import_kit7.address)("ADyA8hdefvWN2dbGGWFotbzWxrAvLW83WG6QCVXvJKqw");
+var PUMP_FUN_PROGRAM_ADDRESS = (0, import_kit6.address)("6EF8rrecthR5Dkzon8Nwu78hRvfCKubJ14M5uBEwF6P");
+var PUMP_FUN_AMM_PROGRAM_ADDRESS = (0, import_kit6.address)("pAMMBay6oceH9fJKBRHGP5D4bD4sWpmSwMn52FMfXEA");
+var WRAPPED_NATIVE_TOKEN_PUBKEY = (0, import_kit6.address)("So11111111111111111111111111111111111111112");
+var GLOBAL_CONFIG_AMM = (0, import_kit6.address)("ADyA8hdefvWN2dbGGWFotbzWxrAvLW83WG6QCVXvJKqw");
 var ANCHOR_DISCRIMINATOR_SIZE = 8;
 var globalAccountCache = null;
 var globalConfigCache = null;
 var migratedPoolCache = /* @__PURE__ */ new Map();
 var poolTokensInfoCache = /* @__PURE__ */ new Map();
 async function findBondingCurvePda(tokenMint) {
-  const [pda] = await (0, import_kit7.getProgramDerivedAddress)({
+  const [pda] = await (0, import_kit6.getProgramDerivedAddress)({
     programAddress: PUMP_FUN_PROGRAM_ADDRESS,
-    seeds: [new TextEncoder().encode("bonding-curve"), (0, import_kit7.getAddressEncoder)().encode(tokenMint)]
+    seeds: [new TextEncoder().encode("bonding-curve"), (0, import_kit6.getAddressEncoder)().encode(tokenMint)]
   });
   return pda;
 }
 async function findGlobalAccountPda() {
-  const [pda] = await (0, import_kit7.getProgramDerivedAddress)({
+  const [pda] = await (0, import_kit6.getProgramDerivedAddress)({
     programAddress: PUMP_FUN_PROGRAM_ADDRESS,
     seeds: [new TextEncoder().encode("global")]
   });
   return pda;
 }
 async function findPoolAuthorityPdaAmm(mint) {
-  const [pda] = await (0, import_kit7.getProgramDerivedAddress)({
+  const [pda] = await (0, import_kit6.getProgramDerivedAddress)({
     programAddress: PUMP_FUN_PROGRAM_ADDRESS,
-    seeds: [new TextEncoder().encode("pool-authority"), (0, import_kit7.getAddressEncoder)().encode(mint)]
+    seeds: [new TextEncoder().encode("pool-authority"), (0, import_kit6.getAddressEncoder)().encode(mint)]
   });
   return pda;
 }
 async function findPoolPdaAmm(poolAuthority, baseMint, quoteMint) {
-  const [pda] = await (0, import_kit7.getProgramDerivedAddress)({
+  const [pda] = await (0, import_kit6.getProgramDerivedAddress)({
     programAddress: PUMP_FUN_AMM_PROGRAM_ADDRESS,
     seeds: [
       new TextEncoder().encode("pool"),
       new Uint8Array([0, 0]),
       // Pool type bytes
-      (0, import_kit7.getAddressEncoder)().encode(poolAuthority),
-      (0, import_kit7.getAddressEncoder)().encode(baseMint),
-      (0, import_kit7.getAddressEncoder)().encode(quoteMint)
+      (0, import_kit6.getAddressEncoder)().encode(poolAuthority),
+      (0, import_kit6.getAddressEncoder)().encode(baseMint),
+      (0, import_kit6.getAddressEncoder)().encode(quoteMint)
     ]
   });
   return pda;
@@ -5451,7 +5360,7 @@ async function getPumpFunBondingCurve(tokenMint) {
   const rpc = getDefaultSolanaRPC();
   try {
     const pda = await findBondingCurvePda(tokenMint);
-    const encodedAccount = await (0, import_kit7.fetchEncodedAccount)(rpc, pda);
+    const encodedAccount = await (0, import_kit6.fetchEncodedAccount)(rpc, pda);
     if (!encodedAccount.exists) {
       throw new Error(`Bonding curve account not found for token mint: ${tokenMint}`);
     }
@@ -5475,7 +5384,7 @@ async function getPumpFunGlobalAccount() {
   }
   const rpc = getDefaultSolanaRPC();
   const pda = await findGlobalAccountPda();
-  const encodedAccount = await (0, import_kit7.fetchEncodedAccount)(rpc, pda);
+  const encodedAccount = await (0, import_kit6.fetchEncodedAccount)(rpc, pda);
   if (!encodedAccount.exists) {
     throw new Error(`GlobalAccount not found: ${pda}`);
   }
@@ -5502,7 +5411,7 @@ async function getPumpFunGlobalConfig() {
     return globalConfigCache.data;
   }
   const rpc = getDefaultSolanaRPC();
-  const encodedAccount = await (0, import_kit7.fetchEncodedAccount)(rpc, GLOBAL_CONFIG_AMM);
+  const encodedAccount = await (0, import_kit6.fetchEncodedAccount)(rpc, GLOBAL_CONFIG_AMM);
   if (!encodedAccount.exists) {
     throw new Error(`GlobalConfig account not found: ${GLOBAL_CONFIG_AMM}`);
   }
@@ -5532,7 +5441,7 @@ async function getPumpFunMigratedPool(baseMint) {
   try {
     const poolAuthorityPda = await findPoolAuthorityPdaAmm(baseMint);
     const poolPda = await findPoolPdaAmm(poolAuthorityPda, baseMint, WRAPPED_NATIVE_TOKEN_PUBKEY);
-    const encodedAccount = await (0, import_kit7.fetchEncodedAccount)(rpc, poolPda);
+    const encodedAccount = await (0, import_kit6.fetchEncodedAccount)(rpc, poolPda);
     if (!encodedAccount.exists) {
       throw new Error(`Migrated pool not found for token mint: ${baseMint}`);
     }
@@ -5561,7 +5470,7 @@ async function getPoolTokensInfo(poolBaseTokenAccount, poolQuoteTokenAccount) {
     return cached.data;
   }
   const rpc = getDefaultSolanaRPC();
-  const accountsInfo = await (0, import_kit7.fetchEncodedAccounts)(rpc, [poolBaseTokenAccount, poolQuoteTokenAccount]);
+  const accountsInfo = await (0, import_kit6.fetchEncodedAccounts)(rpc, [poolBaseTokenAccount, poolQuoteTokenAccount]);
   const baseAccountInfo = accountsInfo[0];
   if (!baseAccountInfo || !baseAccountInfo.exists) {
     throw new Error(`Base token account not found: ${poolBaseTokenAccount}`);
@@ -5576,22 +5485,22 @@ async function getPoolTokensInfo(poolBaseTokenAccount, poolQuoteTokenAccount) {
     mint: baseDecoded.mint,
     owner: baseDecoded.owner,
     amount: baseDecoded.amount,
-    delegate: (0, import_kit7.unwrapOption)(baseDecoded.delegate),
+    delegate: (0, import_kit6.unwrapOption)(baseDecoded.delegate),
     state: baseDecoded.state,
-    isNative: (0, import_kit7.unwrapOption)(baseDecoded.isNative),
+    isNative: (0, import_kit6.unwrapOption)(baseDecoded.isNative),
     delegatedAmount: baseDecoded.delegatedAmount,
-    closeAuthority: (0, import_kit7.unwrapOption)(baseDecoded.closeAuthority)
+    closeAuthority: (0, import_kit6.unwrapOption)(baseDecoded.closeAuthority)
   };
   const quoteDecoded = tokenDecoder.decode(quoteAccountInfo.data);
   const quoteTokenAccount = {
     mint: quoteDecoded.mint,
     owner: quoteDecoded.owner,
     amount: quoteDecoded.amount,
-    delegate: (0, import_kit7.unwrapOption)(quoteDecoded.delegate),
+    delegate: (0, import_kit6.unwrapOption)(quoteDecoded.delegate),
     state: quoteDecoded.state,
-    isNative: (0, import_kit7.unwrapOption)(quoteDecoded.isNative),
+    isNative: (0, import_kit6.unwrapOption)(quoteDecoded.isNative),
     delegatedAmount: quoteDecoded.delegatedAmount,
-    closeAuthority: (0, import_kit7.unwrapOption)(quoteDecoded.closeAuthority)
+    closeAuthority: (0, import_kit6.unwrapOption)(quoteDecoded.closeAuthority)
   };
   poolTokensInfoCache.set(cacheKey, {
     data: [baseTokenAccount, quoteTokenAccount],
@@ -5812,8 +5721,8 @@ function estimatePumpFunAmm(baseToken, quoteToken, globalConfig, amount, tradeTy
 // src/utils/quote/pumpfun/index.ts
 var PumpFunQuoteProvider = class {
   async getQuote(raydiumParams) {
-    const inputMint = (0, import_kit8.address)(raydiumParams.inputMint);
-    const outputMint = (0, import_kit8.address)(raydiumParams.outputMint);
+    const inputMint = (0, import_kit7.address)(raydiumParams.inputMint);
+    const outputMint = (0, import_kit7.address)(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;
@@ -6074,10 +5983,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
+var import_actions = require("viem/actions");
+init_chains();
+
+// 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 (0, import_actions.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 {
@@ -6094,6 +6086,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");
     }
@@ -6123,9 +6116,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,
@@ -6137,12 +6140,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
     };
   }
@@ -6601,7 +6611,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() {
@@ -6782,13 +6795,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;
@@ -6848,7 +6870,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);
@@ -6917,30 +6939,36 @@ 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
-var import_kit9 = require("@solana/kit");
+var import_kit8 = require("@solana/kit");
 init_constants();
 var import_token3 = require("@solana-program/token");
 var import_system2 = require("@solana-program/system");
 async function getSolanaDcaSingleChainOrderInstructions(order, options) {
-  const rpc = options?.rpcUrl ? (0, import_kit9.createSolanaRpc)(options.rpcUrl) : getDefaultSolanaRPC();
-  const orderSigner = await (0, import_kit9.generateKeyPairSigner)();
-  const userSigner = (0, import_kit9.createNoopSigner)(order.user);
-  const feePayerSigner = resolveSolanaFeePayer(userSigner, options?.feePayer);
-  let tokenInMint = (0, import_kit9.address)(order.tokenIn);
+  const rpc = options?.rpcUrl ? (0, import_kit8.createSolanaRpc)(options.rpcUrl) : getDefaultSolanaRPC();
+  const orderSigner = await (0, import_kit8.generateKeyPairSigner)();
+  const signer = (0, import_kit8.createNoopSigner)(order.user);
+  let tokenInMint = (0, import_kit8.address)(order.tokenIn);
   const { secretHash, secretNumber } = genSecretHashAndNumber(order);
-  const orderUserAddress = (0, import_kit9.address)(order.user);
+  const orderUserAddress = (0, import_kit8.address)(order.user);
   const spendingNative = tokenInMint === NATIVE_SOLANA_TOKEN_ADDRESS;
   if (spendingNative) {
     tokenInMint = WRAPPED_SOL_MINT_ADDRESS;
   }
   const tokenMintProgram = await (0, import_token3.fetchMint)(rpc, tokenInMint);
-  const guardAddress = (0, import_kit9.address)(SINGLE_CHAIN_GUARD_ADDRESSES[7565164 /* Solana */]);
-  const addressEncoder = (0, import_kit9.getAddressEncoder)();
+  const guardAddress = (0, import_kit8.address)(SINGLE_CHAIN_GUARD_ADDRESSES[7565164 /* Solana */]);
+  const addressEncoder = (0, import_kit8.getAddressEncoder)();
   const instructions = [];
-  const [tokenInProgramAccount] = await (0, import_kit9.getProgramDerivedAddress)({
+  const [tokenInProgramAccount] = await (0, import_kit8.getProgramDerivedAddress)({
     programAddress: import_token3.ASSOCIATED_TOKEN_PROGRAM_ADDRESS,
     seeds: [
       addressEncoder.encode(orderUserAddress),
@@ -6948,10 +6976,10 @@ async function getSolanaDcaSingleChainOrderInstructions(order, options) {
       addressEncoder.encode(tokenInMint)
     ]
   });
-  const userTokenInAccount = await (0, import_kit9.fetchEncodedAccount)(rpc, tokenInProgramAccount);
+  const userTokenInAccount = await (0, import_kit8.fetchEncodedAccount)(rpc, tokenInProgramAccount);
   if (!userTokenInAccount.exists) {
     const createAccountIx = await (0, import_token3.getCreateAssociatedTokenInstructionAsync)({
-      payer: feePayerSigner,
+      payer: signer,
       ata: tokenInProgramAccount,
       owner: orderUserAddress,
       mint: tokenMintProgram.address,
@@ -6964,7 +6992,7 @@ async function getSolanaDcaSingleChainOrderInstructions(order, options) {
     const transferIx = (0, import_system2.getTransferSolInstruction)({
       amount: totalAmountIn,
       destination: userTokenInAccount.address,
-      source: userSigner
+      source: signer
     });
     instructions.push(transferIx);
     const syncNativeIx = (0, import_token3.getSyncNativeInstruction)({
@@ -6973,7 +7001,7 @@ async function getSolanaDcaSingleChainOrderInstructions(order, options) {
     instructions.push(syncNativeIx);
   }
   const createDcaOrderIx = await getCreateDcaOrderInstructionAsync({
-    user: userSigner,
+    user: signer,
     order: orderSigner,
     guard: guardAddress,
     tokenInMint,
@@ -6989,26 +7017,16 @@ async function getSolanaDcaSingleChainOrderInstructions(order, options) {
     // TODO: Implement extra transfers
   });
   instructions.push(createDcaOrderIx);
-  const tip = resolveSolanaTip(options);
-  if (tip) {
-    instructions.push(
-      (0, import_system2.getTransferSolInstruction)({
-        source: feePayerSigner,
-        destination: tip.account,
-        amount: tip.lamports
-      })
-    );
-  }
   const { value: latestBlockhash } = await rpc.getLatestBlockhash({ commitment: "confirmed" }).send();
-  const txMessage = (0, import_kit9.pipe)(
-    (0, import_kit9.createTransactionMessage)({ version: 0 }),
-    (tx) => (0, import_kit9.setTransactionMessageFeePayerSigner)(feePayerSigner, tx),
-    (tx) => (0, import_kit9.setTransactionMessageLifetimeUsingBlockhash)(latestBlockhash, tx),
-    (tx) => (0, import_kit9.appendTransactionMessageInstructions)(instructions, tx),
-    (tx) => (0, import_kit9.addSignersToTransactionMessage)([orderSigner], tx)
+  const txMessage = (0, import_kit8.pipe)(
+    (0, import_kit8.createTransactionMessage)({ version: 0 }),
+    (tx) => (0, import_kit8.setTransactionMessageFeePayerSigner)(signer, tx),
+    (tx) => (0, import_kit8.setTransactionMessageLifetimeUsingBlockhash)(latestBlockhash, tx),
+    (tx) => (0, import_kit8.appendTransactionMessageInstructions)(instructions, tx),
+    (tx) => (0, import_kit8.addSignersToTransactionMessage)([orderSigner], tx)
   );
-  const partiallySignedTransaction = await (0, import_kit9.partiallySignTransactionMessageWithSigners)(txMessage);
-  const txBytes = (0, import_kit9.getTransactionCodec)().encode(partiallySignedTransaction);
+  const partiallySignedTransaction = await (0, import_kit8.partiallySignTransactionMessageWithSigners)(txMessage);
+  const txBytes = (0, import_kit8.getTransactionCodec)().encode(partiallySignedTransaction);
   return {
     orderAddress: orderSigner.address,
     txBytes,
@@ -7133,9 +7151,7 @@ init_constants();
 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}`);
   }
@@ -7144,12 +7160,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}`);
@@ -7315,15 +7333,15 @@ var EVMSDK = class extends BaseSDK {
 };
 
 // src/core/solana/sdk.ts
-var import_kit12 = require("@solana/kit");
+var import_kit11 = require("@solana/kit");
 
 // src/core/solana/cancel-order.ts
-var import_kit10 = require("@solana/kit");
+var import_kit9 = require("@solana/kit");
 var import_token4 = require("@solana-program/token");
 init_constants();
 async function cancelSingleChainOrderInstructions(orderAddress, options) {
-  const rpc = options?.rpcUrl ? (0, import_kit10.createSolanaRpc)(options.rpcUrl) : getDefaultSolanaRPC();
-  const orderId = (0, import_kit10.address)(orderAddress);
+  const rpc = options?.rpcUrl ? (0, import_kit9.createSolanaRpc)(options.rpcUrl) : getDefaultSolanaRPC();
+  const orderId = (0, import_kit9.address)(orderAddress);
   const chainOrder = await fetchMaybeLimitOrder(rpc, orderId);
   if (!chainOrder.exists) {
     throw new Error(`Order with address ${orderAddress} not found`);
@@ -7332,8 +7350,8 @@ async function cancelSingleChainOrderInstructions(orderAddress, options) {
   const orderUserAddress = chainOrder.data.user;
   const tokenInMint = chainOrder.data.tokenInMint;
   const tokenMintProgram = await (0, import_token4.fetchMint)(rpc, tokenInMint);
-  const addressEncoder = (0, import_kit10.getAddressEncoder)();
-  const [tokenInProgramAccount] = await (0, import_kit10.getProgramDerivedAddress)({
+  const addressEncoder = (0, import_kit9.getAddressEncoder)();
+  const [tokenInProgramAccount] = await (0, import_kit9.getProgramDerivedAddress)({
     programAddress: import_token4.ASSOCIATED_TOKEN_PROGRAM_ADDRESS,
     seeds: [
       addressEncoder.encode(orderUserAddress),
@@ -7342,7 +7360,7 @@ async function cancelSingleChainOrderInstructions(orderAddress, options) {
     ]
   });
   const guardAddress = SINGLE_CHAIN_GUARD_ADDRESSES[7565164 /* Solana */];
-  const [guardProgramAccount] = await (0, import_kit10.getProgramDerivedAddress)({
+  const [guardProgramAccount] = await (0, import_kit9.getProgramDerivedAddress)({
     programAddress: import_token4.ASSOCIATED_TOKEN_PROGRAM_ADDRESS,
     seeds: [
       // Owner
@@ -7353,12 +7371,12 @@ async function cancelSingleChainOrderInstructions(orderAddress, options) {
       addressEncoder.encode(tokenInMint)
     ]
   });
-  const userTokenInAccount = await (0, import_kit10.fetchEncodedAccount)(rpc, tokenInProgramAccount);
+  const userTokenInAccount = await (0, import_kit9.fetchEncodedAccount)(rpc, tokenInProgramAccount);
   if (!userTokenInAccount.exists) {
     const createTokenIx = await (0, import_token4.getCreateAssociatedTokenInstructionAsync)({
       mint: tokenInMint,
       owner: orderUserAddress,
-      payer: (0, import_kit10.createNoopSigner)(orderUserAddress),
+      payer: (0, import_kit9.createNoopSigner)(orderUserAddress),
       tokenProgram: tokenMintProgram.programAddress
     });
     instructions.push(createTokenIx);
@@ -7370,43 +7388,43 @@ async function cancelSingleChainOrderInstructions(orderAddress, options) {
     userTokenInAccount: userTokenInAccount.address,
     guardTokenInAccount: guardProgramAccount,
     tokenInProgram: tokenMintProgram.programAddress,
-    signer: (0, import_kit10.createNoopSigner)(orderUserAddress),
+    signer: (0, import_kit9.createNoopSigner)(orderUserAddress),
     user: orderUserAddress
   });
   instructions.push(cancelLimitOrderIx);
   return instructions;
 }
 async function cancelCrossChainOrderInstructionsAsBytes(orderAddress, signerAddress, options) {
-  const rpc = options?.rpcUrl ? (0, import_kit10.createSolanaRpc)(options.rpcUrl) : getDefaultSolanaRPC();
+  const rpc = options?.rpcUrl ? (0, import_kit9.createSolanaRpc)(options.rpcUrl) : getDefaultSolanaRPC();
   const instructions = await cancelCrossChainOrderInstructions(orderAddress, options);
   const { value: latestBlockhash } = await rpc.getLatestBlockhash({ commitment: "confirmed" }).send();
-  const txMessage = (0, import_kit10.pipe)(
-    (0, import_kit10.createTransactionMessage)({ version: 0 }),
-    (tx) => (0, import_kit10.setTransactionMessageFeePayerSigner)((0, import_kit10.createNoopSigner)((0, import_kit10.address)(signerAddress)), tx),
-    (tx) => (0, import_kit10.setTransactionMessageLifetimeUsingBlockhash)(latestBlockhash, tx),
-    (tx) => (0, import_kit10.appendTransactionMessageInstructions)(instructions, tx)
+  const txMessage = (0, import_kit9.pipe)(
+    (0, import_kit9.createTransactionMessage)({ version: 0 }),
+    (tx) => (0, import_kit9.setTransactionMessageFeePayerSigner)((0, import_kit9.createNoopSigner)((0, import_kit9.address)(signerAddress)), tx),
+    (tx) => (0, import_kit9.setTransactionMessageLifetimeUsingBlockhash)(latestBlockhash, tx),
+    (tx) => (0, import_kit9.appendTransactionMessageInstructions)(instructions, tx)
   );
-  const compiledTxMessage = (0, import_kit10.compileTransactionMessage)(txMessage);
-  const txBytes = (0, import_kit10.getCompiledTransactionMessageEncoder)().encode(compiledTxMessage);
+  const compiledTxMessage = (0, import_kit9.compileTransactionMessage)(txMessage);
+  const txBytes = (0, import_kit9.getCompiledTransactionMessageEncoder)().encode(compiledTxMessage);
   return { versionedMessageBytes: txBytes };
 }
 async function cancelSingleChainOrderInstructionsAsBytes(orderAddress, signerAddress, options) {
-  const rpc = options?.rpcUrl ? (0, import_kit10.createSolanaRpc)(options.rpcUrl) : getDefaultSolanaRPC();
+  const rpc = options?.rpcUrl ? (0, import_kit9.createSolanaRpc)(options.rpcUrl) : getDefaultSolanaRPC();
   const instructions = await cancelSingleChainOrderInstructions(orderAddress, options);
   const { value: latestBlockhash } = await rpc.getLatestBlockhash({ commitment: "confirmed" }).send();
-  const txMessage = (0, import_kit10.pipe)(
-    (0, import_kit10.createTransactionMessage)({ version: 0 }),
-    (tx) => (0, import_kit10.setTransactionMessageFeePayerSigner)((0, import_kit10.createNoopSigner)((0, import_kit10.address)(signerAddress)), tx),
-    (tx) => (0, import_kit10.setTransactionMessageLifetimeUsingBlockhash)(latestBlockhash, tx),
-    (tx) => (0, import_kit10.appendTransactionMessageInstructions)(instructions, tx)
+  const txMessage = (0, import_kit9.pipe)(
+    (0, import_kit9.createTransactionMessage)({ version: 0 }),
+    (tx) => (0, import_kit9.setTransactionMessageFeePayerSigner)((0, import_kit9.createNoopSigner)((0, import_kit9.address)(signerAddress)), tx),
+    (tx) => (0, import_kit9.setTransactionMessageLifetimeUsingBlockhash)(latestBlockhash, tx),
+    (tx) => (0, import_kit9.appendTransactionMessageInstructions)(instructions, tx)
   );
-  const compiledTxMessage = (0, import_kit10.compileTransactionMessage)(txMessage);
-  const txBytes = (0, import_kit10.getCompiledTransactionMessageEncoder)().encode(compiledTxMessage);
+  const compiledTxMessage = (0, import_kit9.compileTransactionMessage)(txMessage);
+  const txBytes = (0, import_kit9.getCompiledTransactionMessageEncoder)().encode(compiledTxMessage);
   return { versionedMessageBytes: txBytes };
 }
 async function cancelCrossChainOrderInstructions(orderAddress, options) {
-  const rpc = options?.rpcUrl ? (0, import_kit10.createSolanaRpc)(options.rpcUrl) : getDefaultSolanaRPC();
-  const orderId = (0, import_kit10.address)(orderAddress);
+  const rpc = options?.rpcUrl ? (0, import_kit9.createSolanaRpc)(options.rpcUrl) : getDefaultSolanaRPC();
+  const orderId = (0, import_kit9.address)(orderAddress);
   const chainOrder = await fetchMaybeOrder(rpc, orderId);
   if (!chainOrder.exists) {
     throw new Error(`Order with address ${orderAddress} not found`);
@@ -7414,11 +7432,11 @@ async function cancelCrossChainOrderInstructions(orderAddress, options) {
   const instructions = [];
   const orderUserAddress = chainOrder.data.user;
   const guardAddress = CROSS_CHAIN_GUARD_ADDRESSES[7565164 /* Solana */];
-  const addressEncoder = (0, import_kit10.getAddressEncoder)();
+  const addressEncoder = (0, import_kit9.getAddressEncoder)();
   const isRecoveringTokenIn = chainOrder.data.lockedStablecoins === 0n;
-  const recoverTokenMint = isRecoveringTokenIn ? chainOrder.data.tokenInMint : (0, import_kit10.address)(SOLANA_MINT_TOKEN.mint);
+  const recoverTokenMint = isRecoveringTokenIn ? chainOrder.data.tokenInMint : (0, import_kit9.address)(SOLANA_MINT_TOKEN.mint);
   const recoverTokenMintProgram = await (0, import_token4.fetchMint)(rpc, recoverTokenMint);
-  const [userRecoveredTokenAccount] = await (0, import_kit10.getProgramDerivedAddress)({
+  const [userRecoveredTokenAccount] = await (0, import_kit9.getProgramDerivedAddress)({
     programAddress: import_token4.ASSOCIATED_TOKEN_PROGRAM_ADDRESS,
     seeds: [
       addressEncoder.encode(orderUserAddress),
@@ -7426,7 +7444,7 @@ async function cancelCrossChainOrderInstructions(orderAddress, options) {
       addressEncoder.encode(recoverTokenMint)
     ]
   });
-  const [guardRecoveredTokenAccount] = await (0, import_kit10.getProgramDerivedAddress)({
+  const [guardRecoveredTokenAccount] = await (0, import_kit9.getProgramDerivedAddress)({
     programAddress: import_token4.ASSOCIATED_TOKEN_PROGRAM_ADDRESS,
     seeds: [
       addressEncoder.encode(guardAddress),
@@ -7434,10 +7452,10 @@ async function cancelCrossChainOrderInstructions(orderAddress, options) {
       addressEncoder.encode(recoverTokenMint)
     ]
   });
-  const userRecoveredTokenAccountInfo = await (0, import_kit10.fetchEncodedAccount)(rpc, userRecoveredTokenAccount);
+  const userRecoveredTokenAccountInfo = await (0, import_kit9.fetchEncodedAccount)(rpc, userRecoveredTokenAccount);
   if (!userRecoveredTokenAccountInfo.exists) {
     const createRecoveredTokenAccountIx = await (0, import_token4.getCreateAssociatedTokenInstructionAsync)({
-      payer: (0, import_kit10.createNoopSigner)(orderUserAddress),
+      payer: (0, import_kit9.createNoopSigner)(orderUserAddress),
       ata: userRecoveredTokenAccount,
       owner: orderUserAddress,
       mint: recoverTokenMint,
@@ -7448,9 +7466,9 @@ async function cancelCrossChainOrderInstructions(orderAddress, options) {
   let userCollateralTokenAccount;
   const willClaimCollateral = chainOrder.data.lockedCollateral > 0n;
   if (willClaimCollateral) {
-    const collateralTokenMint2 = (0, import_kit10.address)(SOLANA_MINT_TOKEN.mint);
+    const collateralTokenMint2 = (0, import_kit9.address)(SOLANA_MINT_TOKEN.mint);
     const collateralTokenMintProgram2 = await (0, import_token4.fetchMint)(rpc, collateralTokenMint2);
-    const [userCollateralAccount] = await (0, import_kit10.getProgramDerivedAddress)({
+    const [userCollateralAccount] = await (0, import_kit9.getProgramDerivedAddress)({
       programAddress: import_token4.ASSOCIATED_TOKEN_PROGRAM_ADDRESS,
       seeds: [
         addressEncoder.encode(orderUserAddress),
@@ -7459,10 +7477,10 @@ async function cancelCrossChainOrderInstructions(orderAddress, options) {
       ]
     });
     userCollateralTokenAccount = userCollateralAccount;
-    const userCollateralTokenAccountInfo = await (0, import_kit10.fetchEncodedAccount)(rpc, userCollateralTokenAccount);
+    const userCollateralTokenAccountInfo = await (0, import_kit9.fetchEncodedAccount)(rpc, userCollateralTokenAccount);
     if (!userCollateralTokenAccountInfo.exists) {
       const createCollateralTokenAccountIx = await (0, import_token4.getCreateAssociatedTokenInstructionAsync)({
-        payer: (0, import_kit10.createNoopSigner)(orderUserAddress),
+        payer: (0, import_kit9.createNoopSigner)(orderUserAddress),
         ata: userCollateralTokenAccount,
         owner: orderUserAddress,
         mint: collateralTokenMint2,
@@ -7471,9 +7489,9 @@ async function cancelCrossChainOrderInstructions(orderAddress, options) {
       instructions.push(createCollateralTokenAccountIx);
     }
   }
-  const collateralTokenMint = (0, import_kit10.address)(SOLANA_MINT_TOKEN.mint);
+  const collateralTokenMint = (0, import_kit9.address)(SOLANA_MINT_TOKEN.mint);
   const collateralTokenMintProgram = await (0, import_token4.fetchMint)(rpc, collateralTokenMint);
-  const [guardCollateralTokenAccount] = await (0, import_kit10.getProgramDerivedAddress)({
+  const [guardCollateralTokenAccount] = await (0, import_kit9.getProgramDerivedAddress)({
     programAddress: import_token4.ASSOCIATED_TOKEN_PROGRAM_ADDRESS,
     seeds: [
       addressEncoder.encode(guardAddress),
@@ -7493,7 +7511,7 @@ async function cancelCrossChainOrderInstructions(orderAddress, options) {
     userCollateralTokenAccount,
     guardCollateralTokenAccount,
     collateralTokenProgram: collateralTokenMintProgram.programAddress,
-    signer: (0, import_kit10.createNoopSigner)(orderUserAddress)
+    signer: (0, import_kit9.createNoopSigner)(orderUserAddress)
   });
   instructions.push(cancelOrderIx);
   return instructions;
@@ -7503,12 +7521,12 @@ async function cancelCrossChainOrderInstructions(orderAddress, options) {
 var import_viem11 = require("viem");
 
 // src/core/solana/dca/cancel-order.ts
-var import_kit11 = require("@solana/kit");
+var import_kit10 = require("@solana/kit");
 var import_token5 = require("@solana-program/token");
 init_constants();
 async function cancelDcaSingleChainOrderInstructions(orderAddress, options) {
-  const rpc = options?.rpcUrl ? (0, import_kit11.createSolanaRpc)(options.rpcUrl) : getDefaultSolanaRPC();
-  const orderId = (0, import_kit11.address)(orderAddress);
+  const rpc = options?.rpcUrl ? (0, import_kit10.createSolanaRpc)(options.rpcUrl) : getDefaultSolanaRPC();
+  const orderId = (0, import_kit10.address)(orderAddress);
   const chainOrder = await fetchMaybeDcaOrder(rpc, orderId);
   if (!chainOrder.exists) {
     throw new Error(`Order with address ${orderAddress} not found`);
@@ -7517,8 +7535,8 @@ async function cancelDcaSingleChainOrderInstructions(orderAddress, options) {
   const orderUserAddress = chainOrder.data.user;
   const tokenInMint = chainOrder.data.tokenInMint;
   const tokenMintProgram = await (0, import_token5.fetchMint)(rpc, tokenInMint);
-  const addressEncoder = (0, import_kit11.getAddressEncoder)();
-  const [tokenInProgramAccount] = await (0, import_kit11.getProgramDerivedAddress)({
+  const addressEncoder = (0, import_kit10.getAddressEncoder)();
+  const [tokenInProgramAccount] = await (0, import_kit10.getProgramDerivedAddress)({
     programAddress: import_token5.ASSOCIATED_TOKEN_PROGRAM_ADDRESS,
     seeds: [
       addressEncoder.encode(orderUserAddress),
@@ -7527,7 +7545,7 @@ async function cancelDcaSingleChainOrderInstructions(orderAddress, options) {
     ]
   });
   const guardAddress = SINGLE_CHAIN_GUARD_ADDRESSES[7565164 /* Solana */];
-  const [guardProgramAccount] = await (0, import_kit11.getProgramDerivedAddress)({
+  const [guardProgramAccount] = await (0, import_kit10.getProgramDerivedAddress)({
     programAddress: import_token5.ASSOCIATED_TOKEN_PROGRAM_ADDRESS,
     seeds: [
       // Owner
@@ -7538,19 +7556,19 @@ async function cancelDcaSingleChainOrderInstructions(orderAddress, options) {
       addressEncoder.encode(tokenInMint)
     ]
   });
-  const userTokenInAccount = await (0, import_kit11.fetchEncodedAccount)(rpc, tokenInProgramAccount);
+  const userTokenInAccount = await (0, import_kit10.fetchEncodedAccount)(rpc, tokenInProgramAccount);
   if (!userTokenInAccount.exists) {
     const createTokenIx = await (0, import_token5.getCreateAssociatedTokenInstructionAsync)({
       mint: tokenInMint,
       owner: orderUserAddress,
-      payer: (0, import_kit11.createNoopSigner)(orderUserAddress),
+      payer: (0, import_kit10.createNoopSigner)(orderUserAddress),
       tokenProgram: tokenMintProgram.programAddress
     });
     instructions.push(createTokenIx);
   }
   const cancelLimitOrderIx = getCancelDcaOrderInstruction({
     user: orderUserAddress,
-    signer: (0, import_kit11.createNoopSigner)(orderUserAddress),
+    signer: (0, import_kit10.createNoopSigner)(orderUserAddress),
     order: orderId,
     guard: guardAddress,
     tokenInMint: chainOrder.data.tokenInMint,
@@ -7594,17 +7612,17 @@ 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 = (0, import_kit12.createNoopSigner)(signer.address);
+    const noopSigner = (0, import_kit11.createNoopSigner)(signer.address);
     const { value: latestBlockhash } = await this.client.rpc.getLatestBlockhash({ commitment: this.config.commitment }).send();
-    const transactionMessage = (0, import_kit12.pipe)(
-      (0, import_kit12.createTransactionMessage)({ version: 0 }),
-      (tx) => (0, import_kit12.setTransactionMessageFeePayerSigner)(noopSigner, tx),
-      (tx) => (0, import_kit12.setTransactionMessageLifetimeUsingBlockhash)(latestBlockhash, tx),
-      (tx) => (0, import_kit12.appendTransactionMessageInstructions)(instructions, tx)
+    const transactionMessage = (0, import_kit11.pipe)(
+      (0, import_kit11.createTransactionMessage)({ version: 0 }),
+      (tx) => (0, import_kit11.setTransactionMessageFeePayerSigner)(noopSigner, tx),
+      (tx) => (0, import_kit11.setTransactionMessageLifetimeUsingBlockhash)(latestBlockhash, tx),
+      (tx) => (0, import_kit11.appendTransactionMessageInstructions)(instructions, tx)
     );
-    const myTx = (0, import_kit12.compileTransaction)(transactionMessage);
-    const signature = await (0, import_kit12.signTransaction)([signerKeyPair], myTx);
-    (0, import_kit12.assertIsSendableTransaction)(signature);
+    const myTx = (0, import_kit11.compileTransaction)(transactionMessage);
+    const signature = await (0, import_kit11.signTransaction)([signerKeyPair], myTx);
+    (0, import_kit11.assertIsSendableTransaction)(signature);
     await this.client.sendAndConfirmTransaction(signature, {
       commitment: this.config.commitment
     });
@@ -7614,17 +7632,17 @@ 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 = (0, import_kit12.createNoopSigner)(signer.address);
+    const noopSigner = (0, import_kit11.createNoopSigner)(signer.address);
     const { value: latestBlockhash } = await this.client.rpc.getLatestBlockhash({ commitment: this.config.commitment }).send();
-    const transactionMessage = (0, import_kit12.pipe)(
-      (0, import_kit12.createTransactionMessage)({ version: 0 }),
-      (tx) => (0, import_kit12.setTransactionMessageFeePayerSigner)(noopSigner, tx),
-      (tx) => (0, import_kit12.setTransactionMessageLifetimeUsingBlockhash)(latestBlockhash, tx),
-      (tx) => (0, import_kit12.appendTransactionMessageInstructions)(instructions, tx)
+    const transactionMessage = (0, import_kit11.pipe)(
+      (0, import_kit11.createTransactionMessage)({ version: 0 }),
+      (tx) => (0, import_kit11.setTransactionMessageFeePayerSigner)(noopSigner, tx),
+      (tx) => (0, import_kit11.setTransactionMessageLifetimeUsingBlockhash)(latestBlockhash, tx),
+      (tx) => (0, import_kit11.appendTransactionMessageInstructions)(instructions, tx)
     );
-    const myTx = (0, import_kit12.compileTransaction)(transactionMessage);
-    const signature = await (0, import_kit12.signTransaction)([signerKeyPair], myTx);
-    (0, import_kit12.assertIsSendableTransaction)(signature);
+    const myTx = (0, import_kit11.compileTransaction)(transactionMessage);
+    const signature = await (0, import_kit11.signTransaction)([signerKeyPair], myTx);
+    (0, import_kit11.assertIsSendableTransaction)(signature);
     await this.client.sendAndConfirmTransaction(signature, {
       commitment: this.config.commitment
     });
@@ -7639,9 +7657,9 @@ var SolanaSDK = class extends BaseSDK {
    * @private
    */
   async getUserCryptoKeypair() {
-    const encoder = (0, import_kit12.getBase58Encoder)();
+    const encoder = (0, import_kit11.getBase58Encoder)();
     const bytesWithPrefix = encoder.encode(this.config.privateKey);
-    return (0, import_kit12.createKeyPairFromBytes)(bytesWithPrefix);
+    return (0, import_kit11.createKeyPairFromBytes)(bytesWithPrefix);
   }
   /**
    * Creates a KeyPairSigner from the user's crypto keypair
@@ -7653,7 +7671,7 @@ var SolanaSDK = class extends BaseSDK {
    */
   async getUserSigner() {
     const signer = await this.getUserCryptoKeypair();
-    return (0, import_kit12.createSignerFromKeyPair)(signer);
+    return (0, import_kit11.createSignerFromKeyPair)(signer);
   }
   async authenticate(token) {
     const wallet = await this.getUserAddress();
@@ -7662,10 +7680,10 @@ var SolanaSDK = class extends BaseSDK {
       wallet
     });
     const message = response.data;
-    const signableMessage = (0, import_kit12.createSignableMessage)(message);
+    const signableMessage = (0, import_kit11.createSignableMessage)(message);
     const signer = await this.getUserSigner();
     const signatureArray = await signer.signMessages([signableMessage]);
-    const signatureBytes = signatureArray.map((signature) => signature[(0, import_kit12.address)(wallet)])[0];
+    const signatureBytes = signatureArray.map((signature) => signature[(0, import_kit11.address)(wallet)])[0];
     if (!signatureBytes) {
       throw new Error("No signature bytes found");
     }
@@ -7696,10 +7714,10 @@ var SolanaSDK = class extends BaseSDK {
   async prepareCrossChainOrder(order) {
     const signerKeyPair = await this.getUserCryptoKeypair();
     const { orderAddress, txBytes } = await getSolanaCrossChainOrderInstructions(order);
-    const transactionCodec = (0, import_kit12.getTransactionCodec)();
+    const transactionCodec = (0, import_kit11.getTransactionCodec)();
     const tx = transactionCodec.decode(txBytes);
-    const signedTx = await (0, import_kit12.signTransaction)([signerKeyPair], tx);
-    const encodedTransaction = (0, import_kit12.getBase64EncodedWireTransaction)(signedTx);
+    const signedTx = await (0, import_kit11.signTransaction)([signerKeyPair], tx);
+    const encodedTransaction = (0, import_kit11.getBase64EncodedWireTransaction)(signedTx);
     await this.client.rpc.sendTransaction(encodedTransaction, { preflightCommitment: this.config.commitment, encoding: "base64" }).send();
     return {
       order,
@@ -7711,10 +7729,10 @@ var SolanaSDK = class extends BaseSDK {
   async prepareSingleChainOrder(order) {
     const signerKeyPair = await this.getUserCryptoKeypair();
     const { orderAddress, txBytes, secretNumber } = await getSolanaSingleChainOrderInstructions(order);
-    const transactionCodec = (0, import_kit12.getTransactionCodec)();
+    const transactionCodec = (0, import_kit11.getTransactionCodec)();
     const tx = transactionCodec.decode(txBytes);
-    const signedTx = await (0, import_kit12.partiallySignTransaction)([signerKeyPair], tx);
-    const encodedTransaction = (0, import_kit12.getBase64EncodedWireTransaction)(signedTx);
+    const signedTx = await (0, import_kit11.partiallySignTransaction)([signerKeyPair], tx);
+    const encodedTransaction = (0, import_kit11.getBase64EncodedWireTransaction)(signedTx);
     await this.client.rpc.sendTransaction(encodedTransaction, { preflightCommitment: this.config.commitment, encoding: "base64" }).send();
     return {
       order,
@@ -7728,17 +7746,17 @@ 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 = (0, import_kit12.createNoopSigner)(signer.address);
+    const noopSigner = (0, import_kit11.createNoopSigner)(signer.address);
     const { value: latestBlockhash } = await this.client.rpc.getLatestBlockhash({ commitment: this.config.commitment }).send();
-    const transactionMessage = (0, import_kit12.pipe)(
-      (0, import_kit12.createTransactionMessage)({ version: 0 }),
-      (tx) => (0, import_kit12.setTransactionMessageFeePayerSigner)(noopSigner, tx),
-      (tx) => (0, import_kit12.setTransactionMessageLifetimeUsingBlockhash)(latestBlockhash, tx),
-      (tx) => (0, import_kit12.appendTransactionMessageInstructions)(instructions, tx)
+    const transactionMessage = (0, import_kit11.pipe)(
+      (0, import_kit11.createTransactionMessage)({ version: 0 }),
+      (tx) => (0, import_kit11.setTransactionMessageFeePayerSigner)(noopSigner, tx),
+      (tx) => (0, import_kit11.setTransactionMessageLifetimeUsingBlockhash)(latestBlockhash, tx),
+      (tx) => (0, import_kit11.appendTransactionMessageInstructions)(instructions, tx)
     );
-    const myTx = (0, import_kit12.compileTransaction)(transactionMessage);
-    const signature = await (0, import_kit12.signTransaction)([signerKeyPair], myTx);
-    (0, import_kit12.assertIsSendableTransaction)(signature);
+    const myTx = (0, import_kit11.compileTransaction)(transactionMessage);
+    const signature = await (0, import_kit11.signTransaction)([signerKeyPair], myTx);
+    (0, import_kit11.assertIsSendableTransaction)(signature);
     await this.client.sendAndConfirmTransaction(signature, {
       commitment: this.config.commitment
     });
@@ -7747,10 +7765,10 @@ var SolanaSDK = class extends BaseSDK {
   async prepareDcaSingleChainOrder(order) {
     const signerKeyPair = await this.getUserCryptoKeypair();
     const { orderAddress, txBytes, secretNumber } = await getSolanaDcaSingleChainOrderInstructions(order);
-    const transactionCodec = (0, import_kit12.getTransactionCodec)();
+    const transactionCodec = (0, import_kit11.getTransactionCodec)();
     const tx = transactionCodec.decode(txBytes);
-    const signedTx = await (0, import_kit12.partiallySignTransaction)([signerKeyPair], tx);
-    const encodedTransaction = (0, import_kit12.getBase64EncodedWireTransaction)(signedTx);
+    const signedTx = await (0, import_kit11.partiallySignTransaction)([signerKeyPair], tx);
+    const encodedTransaction = (0, import_kit11.getBase64EncodedWireTransaction)(signedTx);
     await this.client.rpc.sendTransaction(encodedTransaction, { preflightCommitment: this.config.commitment, encoding: "base64" }).send();
     return {
       order,
@@ -7902,31 +7920,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 {
@@ -7941,10 +7934,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) {
@@ -7954,6 +7947,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();
 
@@ -8172,7 +8173,7 @@ function getInvalidateNoncesRawData(nonce) {
 }
 
 // src/core/solana/inspect.ts
-var import_kit13 = require("@solana/kit");
+var import_kit12 = require("@solana/kit");
 
 // src/utils/logger.ts
 init_errors();
@@ -8267,8 +8268,8 @@ var logger = Logger.getInstance();
 
 // src/core/solana/inspect.ts
 async function getSolanaOrdersWithLockedFunds(userAddress, config) {
-  const rpc = config?.rpcUrl ? (0, import_kit13.createSolanaRpc)(config.rpcUrl) : getDefaultSolanaRPC();
-  const programAccountAddress = (0, import_kit13.address)("DQZQGiVa1PBXesdbCRzmJpZ7AyntLXfAwP5Qty1hgFqQ");
+  const rpc = config?.rpcUrl ? (0, import_kit12.createSolanaRpc)(config.rpcUrl) : getDefaultSolanaRPC();
+  const programAccountAddress = (0, import_kit12.address)("DQZQGiVa1PBXesdbCRzmJpZ7AyntLXfAwP5Qty1hgFqQ");
   const programAccountsConfig = {
     encoding: "base64",
     filters: [
@@ -8384,27 +8385,7 @@ init_single_chain_limit_order();
 
 // src/utils/generate-execution-details-hash.ts
 var import_crypto = require("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" + (0, import_crypto.createHash)("sha256").update(executionDetails).digest("hex");
 }
 
@@ -8422,7 +8403,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,
@@ -8472,7 +8455,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,
@@ -8701,6 +8684,7 @@ async function getTokenList(params) {
 }
 
 // src/core/evm/intent-helpers.ts
+init_constants();
 function createEvmSingleChainLimitOrderIntentRequest(params) {
   const order = {
     user: params.user,
@@ -8721,7 +8705,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
       }
     }
   };
@@ -8746,7 +8730,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
       }
     }
   };
@@ -8763,7 +8747,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,
@@ -8772,10 +8756,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,
@@ -8783,7 +8764,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
       }
     }
   };
@@ -8800,6 +8781,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) {
@@ -8861,11 +8911,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,
@@ -8886,14 +8937,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();