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

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_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, DEV_ACCESS_KEY;
+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,6 +233,7 @@ 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_USDC_MINT = {
@@ -241,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;
@@ -259,8 +266,9 @@ 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";
-    DEV_ACCESS_KEY = typeof window !== "undefined" ? localStorage.getItem("x-dev-access") : null;
   }
 });
 
@@ -375,10 +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_KEY: () => DEV_ACCESS_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,
@@ -417,6 +427,7 @@ __export(index_exports, {
   cancelDcaSingleChainOrderInstructions: () => cancelDcaSingleChainOrderInstructions,
   cancelSingleChainOrderInstructionsAsBytes: () => cancelSingleChainOrderInstructionsAsBytes,
   chainIdToChainTypeMap: () => chainIdToChainTypeMap,
+  createEvmCrossChainDcaOrderIntentRequest: () => createEvmCrossChainDcaOrderIntentRequest,
   createEvmCrossChainOrderIntentRequest: () => createEvmCrossChainOrderIntentRequest,
   createEvmSingleChainDcaOrderIntentRequest: () => createEvmSingleChainDcaOrderIntentRequest,
   createEvmSingleChainLimitOrderIntentRequest: () => createEvmSingleChainLimitOrderIntentRequest,
@@ -446,6 +457,7 @@ __export(index_exports, {
   getCancelSingleChainOrderRawData: () => getCancelSingleChainOrderRawData,
   getCoinFromResponse: () => getCoinFromResponse,
   getDcaSecretHash: () => getDcaSecretHash,
+  getEVMCrossChainDcaOrderTypedData: () => getEVMCrossChainDcaOrderTypedData,
   getEVMCrossChainOrderTypedData: () => getEVMCrossChainOrderTypedData,
   getEVMSingleChainOrderTypedData: () => getEVMSingleChainOrderTypedData,
   getInvalidateNoncesRawData: () => getInvalidateNoncesRawData,
@@ -466,6 +478,7 @@ __export(index_exports, {
   isNativeEvmToken: () => isNativeEvmToken,
   isSuccessApiResponse: () => isSuccessApiResponse,
   isSupportedChain: () => isSupportedChain,
+  normalizeNativeEvmTokenForSigning: () => normalizeNativeEvmTokenForSigning,
   prepareDcaSecretData: () => prepareDcaSecretData,
   prepareSecretData: () => prepareSecretData,
   signSingleChainDcaOrder: () => signSingleChainDcaOrder,
@@ -502,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);
     }
@@ -3674,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 {
@@ -3740,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
     })) || [];
@@ -3793,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
     })) || [];
@@ -5950,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 {
@@ -5970,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");
     }
@@ -5999,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,
@@ -6013,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
     };
   }
@@ -6477,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() {
@@ -6658,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;
@@ -6724,10 +6870,7 @@ var BaseSDK = class _BaseSDK {
   static async makeRequest(url, body) {
     const response = await fetch(url, {
       method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        ...DEV_ACCESS_KEY ? { "x-dev-access": DEV_ACCESS_KEY } : {}
-      },
+      headers: { "Content-Type": "application/json" },
       body
     });
     console.debug(`url`, url, `body`, body);
@@ -6796,6 +6939,13 @@ 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
@@ -7001,11 +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: {
-      ...DEV_ACCESS_KEY ? { "x-dev-access": DEV_ACCESS_KEY } : {}
-    }
-  });
+  const response = await fetch(url);
   if (!response.ok) {
     throw new Error(`Failed to fetch SIWE message: ${response.status} ${response.statusText}`);
   }
@@ -7014,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: {
-      Authorization: `Bearer ${token}`
-    }
+    headers
   });
   if (!response.ok) {
     throw new Error(`Failed to fetch JWT token: ${response.status} ${response.statusText}`);
@@ -7772,34 +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: {
-      "Content-Type": "application/json",
-      ...DEV_ACCESS_KEY ? { "x-dev-access": DEV_ACCESS_KEY } : {}
-    }
-  });
-  if (!response.ok) {
-    throw new Error(`Failed to fetch user orders: ${response.status} ${response.statusText}`);
-  }
-  const data = 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 {
@@ -7827,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();
 
@@ -8257,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");
 }
 
@@ -8295,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,
@@ -8345,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,
@@ -8574,6 +8684,7 @@ async function getTokenList(params) {
 }
 
 // src/core/evm/intent-helpers.ts
+init_constants();
 function createEvmSingleChainLimitOrderIntentRequest(params) {
   const order = {
     user: params.user,
@@ -8594,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
       }
     }
   };
@@ -8619,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
       }
     }
   };
@@ -8636,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,
@@ -8645,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,
@@ -8656,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
       }
     }
   };
@@ -8673,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) {
@@ -8734,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,