@shogun-sdk/intents-sdk 1.2.31 → 1.4.0

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

@@ -1,10 +1,29 @@
+import type { Address, Hex, TypedDataDefinition } from 'viem';
 import type { SupportedEvmChain } from '../../chains.js';
-import type { SingleChainUserIntentRequest, CrossChainUserIntentRequest, DcaSingleChainUserIntentRequest } from '../../types/intent.js';
+import type {
+  SingleChainUserIntentRequest,
+  CrossChainUserIntentRequest,
+  DcaSingleChainUserIntentRequest,
+  DcaCrossChainUserIntentRequest,
+} from '../../types/intent.js';
 import type { SingleChainOrder } from '../orders/single-chain.js';
 import type { CrossChainOrder } from '../orders/cross-chain.js';
 import type { DcaSingleChainOrder } from '../orders/dca-single-chain.js';
-import type { ExtraTransfer } from '../orders/common.js';
-import { getEVMCrossChainOrderTypedData, getEVMSingleChainOrderTypedData, getEVMDcaSingleChainOrderTypedData } from './order-signature.js';
+import type { ExtraTransfer, StopLossType } from '../orders/common.js';
+import {
+  getEVMCrossChainOrderTypedData,
+  getEVMSingleChainOrderTypedData,
+  getEVMDcaSingleChainOrderTypedData,
+} from './order-signature.js';
+import {
+  CROSS_CHAIN_DCA_PERMIT2_TYPES,
+  PERMIT2_DOMAIN,
+  type CrossChainDcaPermitTransferFrom,
+} from './permit2.js';
+import { EVMIntentProvider } from './intent-provider.js';
+import { DCA_CROSS_CHAIN_GUARD_ADDRESSES, EVM_ZERO_SIGNATURE } from '../../constants.js';
+import { generateExecutionDetailsHash } from '../../utils/generate-execution-details-hash.js';
+import { Parsers } from '../../utils/parsers.js';
 
 export type CreateEvmSingleChainLimitOrderIntentParams = {
   user: `0x${string}`;
@@ -18,8 +37,9 @@ export type CreateEvmSingleChainLimitOrderIntentParams = {
   deadline: number;
   nonce?: string;
   signature?: string;
-  stopLossMaxOut?: bigint;
   takeProfitMinOut?: bigint;
+  stopLossType?: StopLossType;
+  stopLossTriggerPrice?: string;
 };
 
 export type CreateEvmSingleChainDcaOrderIntentParams = {
@@ -53,8 +73,9 @@ export type CreateEvmCrossChainOrderIntentParams = {
   extraTransfers?: ExtraTransfer[];
   nonce?: string;
   signature?: string;
-  stopLossMaxOut?: bigint;
   takeProfitMinOut?: bigint;
+  stopLossType?: StopLossType;
+  stopLossTriggerPrice?: string;
 };
 
 /**
@@ -63,7 +84,7 @@ export type CreateEvmCrossChainOrderIntentParams = {
  * @returns Formatted intent request ready to send to auctioneer
  */
 export function createEvmSingleChainLimitOrderIntentRequest(
-  params: CreateEvmSingleChainLimitOrderIntentParams
+  params: CreateEvmSingleChainLimitOrderIntentParams,
 ): SingleChainUserIntentRequest {
   const order: SingleChainOrder = {
     user: params.user,
@@ -75,8 +96,9 @@ export function createEvmSingleChainLimitOrderIntentRequest(
     destinationAddress: params.destinationAddress,
     extraTransfers: params.extraTransfers,
     deadline: params.deadline,
-    stopLossMaxOut: params.stopLossMaxOut,
     takeProfitMinOut: params.takeProfitMinOut,
+    stopLossType: params.stopLossType,
+    stopLossTriggerPrice: params.stopLossTriggerPrice,
   } as SingleChainOrder;
 
   return {
@@ -84,7 +106,7 @@ export function createEvmSingleChainLimitOrderIntentRequest(
     chainSpecificData: {
       EVM: {
         nonce: params.nonce || String(Math.floor(Math.random() * 10000000)),
-        signature: params.signature || '0x0000000000000000000000000000000000000000000000000000000000000000',
+        signature: params.signature || EVM_ZERO_SIGNATURE,
       },
     },
   };
@@ -96,7 +118,7 @@ export function createEvmSingleChainLimitOrderIntentRequest(
  * @returns Formatted intent request ready to send to auctioneer
  */
 export function createEvmSingleChainDcaOrderIntentRequest(
-  params: CreateEvmSingleChainDcaOrderIntentParams
+  params: CreateEvmSingleChainDcaOrderIntentParams,
 ): DcaSingleChainUserIntentRequest {
   const order: DcaSingleChainOrder = {
     user: params.user,
@@ -118,7 +140,7 @@ export function createEvmSingleChainDcaOrderIntentRequest(
     chainSpecificData: {
       EVM: {
         nonce: params.nonce || String(Math.floor(Math.random() * 10000000)),
-        signature: params.signature || '0x0000000000000000000000000000000000000000000000000000000000000000',
+        signature: params.signature || EVM_ZERO_SIGNATURE,
       },
     },
   };
@@ -130,18 +152,22 @@ export function createEvmSingleChainDcaOrderIntentRequest(
  * @returns Formatted intent request ready to send to auctioneer
  */
 export function createEvmCrossChainOrderIntentRequest(
-  params: CreateEvmCrossChainOrderIntentParams
+  params: CreateEvmCrossChainOrderIntentParams,
 ): CrossChainUserIntentRequest {
-  const executionDetails = JSON.stringify({
+  const executionDetails = {
     destChainId: params.destinationChainId,
     tokenOut: params.destinationTokenAddress,
-    amountOutMin: params.destinationTokenMinAmount || 1n,
+    amountOutMin: params.destinationTokenMinAmount?.toString() || '1',
     destinationAddress: params.destinationAddress,
     extraTransfers: params.extraTransfers,
-  });
+    takeProfitMinOut: params.takeProfitMinOut?.toString(),
+    stopLossType: params.stopLossType,
+    stopLossTriggerPrice: params.stopLossTriggerPrice,
+  };
+  const executionDetailsString = JSON.stringify(executionDetails, Parsers.bigIntReplacer);
 
-  // Calculate execution details hash
-  const executionDetailsHash = `0x${require('crypto').createHash('sha256').update(executionDetails).digest('hex')}` as `0x${string}`;
+  // Hash the exact string we send; the auctioneer recomputes sha256 over it and rejects on mismatch
+  const executionDetailsHash = generateExecutionDetailsHash(executionDetailsString);
 
   const genericData = {
     user: params.user,
@@ -150,19 +176,17 @@ export function createEvmCrossChainOrderIntentRequest(
     amountIn: params.sourceTokenAmount,
     minStablecoinsAmount: params.minStablecoinAmount || 1n,
     deadline: params.deadline,
-    executionDetailsHash,
+    executionDetailsHash: executionDetailsHash as `0x${string}`,
     extraTransfers: params.extraTransfers,
-    stopLossMaxOut: params.stopLossMaxOut,
-    takeProfitMinOut: params.takeProfitMinOut,
   };
 
   return {
     genericData,
-    executionDetails,
+    executionDetails: executionDetailsString,
     chainSpecificData: {
       EVM: {
         nonce: params.nonce || String(Math.floor(Math.random() * 10000000)),
-        signature: params.signature || '0x0000000000000000000000000000000000000000000000000000000000000000',
+        signature: params.signature || EVM_ZERO_SIGNATURE,
       },
     },
   };
@@ -202,3 +226,120 @@ export async function generateEvmCrossChainOrderTypedData(order: CrossChainOrder
 export function generateEvmRandomNonce(): string {
   return String(Math.floor(Math.random() * 10000000));
 }
+
+export type CreateEvmCrossChainDcaOrderIntentParams = {
+  user: `0x${string}`;
+  sourceChainId: SupportedEvmChain;
+  sourceTokenAddress: string;
+  destinationChainId: number;
+  destinationTokenAddress: string;
+  destinationTokenMinAmount?: bigint;
+  destinationAddress: string;
+  minStablecoinAmount?: bigint;
+  deadline: number;
+  startTime: number;
+  amountInPerInterval: bigint;
+  totalIntervals: number;
+  intervalDuration: number;
+  extraTransfers?: ExtraTransfer[];
+  nonce?: string;
+  signature?: string;
+};
+
+/**
+ * Builds the cross-chain DCA execution-details string and its SHA-256 hash.
+ * Both the wire payload and the EIP-712 witness must reference the SAME string/hash, so this
+ * is the single source of truth — the auctioneer recomputes sha256 over the string it receives.
+ */
+function buildCrossChainDcaExecutionDetails(params: CreateEvmCrossChainDcaOrderIntentParams): {
+  executionDetailsString: string;
+  executionDetailsHash: string;
+} {
+  const executionDetails = {
+    destChainId: params.destinationChainId,
+    tokenOut: params.destinationTokenAddress,
+    amountOutMin: params.destinationTokenMinAmount?.toString() || '1',
+    destinationAddress: params.destinationAddress,
+    extraTransfers: params.extraTransfers,
+  };
+  const executionDetailsString = JSON.stringify(executionDetails, Parsers.bigIntReplacer);
+  return { executionDetailsString, executionDetailsHash: generateExecutionDetailsHash(executionDetailsString) };
+}
+
+/**
+ * Creates an EVM cross-chain DCA order intent request, ready to POST to
+ * `/user_intent/cross_chain/dca_order`. Pass `nonce`/`signature` from
+ * {@link getEVMCrossChainDcaOrderTypedData} for an executable order.
+ */
+export function createEvmCrossChainDcaOrderIntentRequest(
+  params: CreateEvmCrossChainDcaOrderIntentParams,
+): DcaCrossChainUserIntentRequest {
+  const { executionDetailsString, executionDetailsHash } = buildCrossChainDcaExecutionDetails(params);
+
+  return {
+    genericData: {
+      user: params.user,
+      srcChainId: params.sourceChainId,
+      tokenIn: params.sourceTokenAddress,
+      minStablecoinsAmount: params.minStablecoinAmount || 1n,
+      deadline: params.deadline,
+      executionDetailsHash: executionDetailsHash as `0x${string}`,
+      startTime: params.startTime,
+      amountInPerInterval: params.amountInPerInterval,
+      totalIntervals: params.totalIntervals,
+      intervalDuration: params.intervalDuration,
+    },
+    executionDetails: executionDetailsString,
+    chainSpecificData: {
+      EVM: {
+        nonce: params.nonce || generateEvmRandomNonce(),
+        signature: params.signature || EVM_ZERO_SIGNATURE,
+      },
+    },
+  };
+}
+
+/**
+ * Generates the EIP-712 typed data (and nonce) for a cross-chain DCA order's Permit2 witness.
+ * Sign `orderTypedData`, then pass the resulting `nonce`/`signature` into
+ * {@link createEvmCrossChainDcaOrderIntentRequest} — both share the same execution-details hash.
+ */
+export function getEVMCrossChainDcaOrderTypedData(
+  params: CreateEvmCrossChainDcaOrderIntentParams,
+  providedNonce?: bigint,
+): { orderTypedData: TypedDataDefinition; nonce: bigint } {
+  const { executionDetailsHash } = buildCrossChainDcaExecutionDetails(params);
+  const nonce = providedNonce ?? EVMIntentProvider.getRandomNonce();
+  const totalAmountIn = params.amountInPerInterval * BigInt(params.totalIntervals);
+  const spender = DCA_CROSS_CHAIN_GUARD_ADDRESSES[params.sourceChainId] as Address;
+
+  const message: CrossChainDcaPermitTransferFrom = {
+    permitted: { token: params.sourceTokenAddress as Address, amount: totalAmountIn },
+    spender,
+    nonce,
+    deadline: BigInt(params.deadline),
+    witness: {
+      user: params.user as Address,
+      tokenIn: params.sourceTokenAddress as Address,
+      srcChainId: params.sourceChainId,
+      startTime: params.startTime,
+      deadline: params.deadline,
+      totalIntervals: params.totalIntervals,
+      intervalDuration: params.intervalDuration,
+      amountInPerInterval: params.amountInPerInterval,
+      minStablecoinsAmountPerInterval: params.minStablecoinAmount || 1n,
+      executionDetailsHash: executionDetailsHash as Hex,
+      nonce,
+    },
+  };
+
+  return {
+    orderTypedData: {
+      domain: PERMIT2_DOMAIN(params.sourceChainId),
+      types: CROSS_CHAIN_DCA_PERMIT2_TYPES,
+      primaryType: 'PermitWitnessTransferFrom',
+      message,
+    },
+    nonce,
+  };
+}

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

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

package/src/core/evm/permit2.ts

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

package/src/core/evm/single-chain-dca-order.ts

@@ -1,20 +1,20 @@
-import { ethers, type TypedDataField, type AddressLike, type BigNumberish, type BytesLike } from "ethers";
-import { SignatureTransfer } from "@uniswap/permit2-sdk";
-import { TransferDataType, type TransferDataStruct } from "./types.js";
+import { ethers, type TypedDataField, type AddressLike, type BigNumberish, type BytesLike } from 'ethers';
+import { SignatureTransfer } from '@uniswap/permit2-sdk';
+import { TransferDataType, type TransferDataStruct } from './types.js';
 
 export const SingleChainDcaOrderType: Record<string, TypedDataField[]> = {
   SingleChainDcaOrder: [
-    { type: "address", name: "user" },
-    { type: "address", name: "tokenIn" },
-    { type: "uint32", name: "startTime" },
-    { type: "uint256", name: "amountInPerInterval" },
-    { type: "uint24", name: "totalIntervals" },
-    { type: "uint32", name: "intervalDuration" },
-    { type: "TransferData", name: "requestedOutput" },
-    { type: "TransferData[]", name: "extraTransfers" },
-    { type: "bytes", name: "encodedExternalCallData" },
-    { type: "uint32", name: "deadline" },
-    { type: "uint256", name: "nonce" },
+    { type: 'address', name: 'user' },
+    { type: 'address', name: 'tokenIn' },
+    { type: 'uint32', name: 'startTime' },
+    { type: 'uint256', name: 'amountInPerInterval' },
+    { type: 'uint24', name: 'totalIntervals' },
+    { type: 'uint32', name: 'intervalDuration' },
+    { type: 'TransferData', name: 'requestedOutput' },
+    { type: 'TransferData[]', name: 'extraTransfers' },
+    { type: 'bytes', name: 'encodedExternalCallData' },
+    { type: 'uint32', name: 'deadline' },
+    { type: 'uint256', name: 'nonce' },
   ],
   TransferData: TransferDataType.TransferData!,
 };
@@ -41,7 +41,7 @@ export async function signSingleChainDcaOrder(
   order: SingleChainDcaOrderStruct,
   chainId: number,
   guardAddress: string,
-  permit2Address: string
+  permit2Address: string,
 ): Promise<{
   domain: any;
   types: any;
@@ -63,9 +63,9 @@ export async function signSingleChainDcaOrder(
     chainId,
     {
       witness: order,
-      witnessTypeName: "SingleChainDcaOrder",
+      witnessTypeName: 'SingleChainDcaOrder',
       witnessType: SingleChainDcaOrderType,
-    }
+    },
   );
 
   return {
@@ -79,7 +79,7 @@ export async function signSingleChainDcaOrder(
         verifyingContract: permitData.domain.verifyingContract,
       },
       permitData.types,
-      permitData.values
+      permitData.values,
     ),
   };
 }

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

@@ -1,17 +1,17 @@
-import { ethers, type TypedDataField, type AddressLike, type BigNumberish, type BytesLike } from "ethers";
-import { SignatureTransfer } from "@uniswap/permit2-sdk";
-import { TransferDataType, type TransferDataStruct } from "./types.js";
+import { ethers, type TypedDataField, type AddressLike, type BigNumberish, type BytesLike } from 'ethers';
+import { SignatureTransfer } from '@uniswap/permit2-sdk';
+import { TransferDataType, type TransferDataStruct } from './types.js';
 
 export const SingleChainLimitOrderType: Record<string, TypedDataField[]> = {
   SingleChainLimitOrder: [
-    { type: "address", name: "user" },
-    { type: "address", name: "tokenIn" },
-    { type: "uint256", name: "amountIn" },
-    { type: "TransferData", name: "requestedOutput" },
-    { type: "TransferData[]", name: "extraTransfers" },
-    { type: "bytes", name: "encodedExternalCallData" },
-    { type: "uint32", name: "deadline" },
-    { type: "uint256", name: "nonce" },
+    { type: 'address', name: 'user' },
+    { type: 'address', name: 'tokenIn' },
+    { type: 'uint256', name: 'amountIn' },
+    { type: 'TransferData', name: 'requestedOutput' },
+    { type: 'TransferData[]', name: 'extraTransfers' },
+    { type: 'bytes', name: 'encodedExternalCallData' },
+    { type: 'uint32', name: 'deadline' },
+    { type: 'uint256', name: 'nonce' },
   ],
   TransferData: TransferDataType.TransferData!,
 };
@@ -35,7 +35,7 @@ export async function signSingleChainLimitOrder(
   order: SingleChainLimitOrderStruct,
   chainId: number,
   guardAddress: string,
-  permit2Address: string
+  permit2Address: string,
 ): Promise<{
   domain: any;
   types: any;
@@ -56,9 +56,9 @@ export async function signSingleChainLimitOrder(
     chainId,
     {
       witness: order,
-      witnessTypeName: "SingleChainLimitOrder",
+      witnessTypeName: 'SingleChainLimitOrder',
       witnessType: SingleChainLimitOrderType,
-    }
+    },
   );
 
   return {
@@ -72,7 +72,7 @@ export async function signSingleChainLimitOrder(
         verifyingContract: permitData.domain.verifyingContract,
       },
       permitData.types,
-      permitData.values
+      permitData.values,
     ),
   };
 }

package/src/core/evm/types.ts

@@ -1,10 +1,10 @@
-import type { AddressLike, BigNumberish, TypedDataField } from "ethers";
+import type { AddressLike, BigNumberish, TypedDataField } from 'ethers';
 
 export const TransferDataType: Record<string, TypedDataField[]> = {
   TransferData: [
-    { type: "address", name: "token" },
-    { type: "address", name: "receiver" },
-    { type: "uint256", name: "amount" },
+    { type: 'address', name: 'token' },
+    { type: 'address', name: 'receiver' },
+    { type: 'uint256', name: 'amount' },
   ],
 };
 

package/src/core/evm/validator.ts

@@ -77,7 +77,7 @@ export class EvmValidator extends BaseValidator {
   ): Promise<void> {
     const chain = order.chainId as SupportedEvmChain;
 
-    const validSingleChainChains = [ChainID.Hyperliquid, ChainID.Base];
+    const validSingleChainChains = [ChainID.Hyperliquid, ChainID.Base, ChainID.BSC, ChainID.Arbitrum, ChainID.Optimism, ChainID.MONAD];
 
     if (!validSingleChainChains.includes(chain)) {
       throw new ValidationError(`Chain ${chain} is not supported for single chain orders`);

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

@@ -1,21 +1,38 @@
-import { AUCTIONEER_URL } from '../../../constants.js';
-import type { ApiResponse, ApiUserOrders } from '../../../types/api.js';
+import { AuctioneerAPI } from './index.js';
+import type { SupportedChain } from '../../../chains.js';
+import type { ApiUserOrders } from '../../../types/api.js';
 
-export async function fetchUserOrders(jwtToken: string): Promise<ApiUserOrders> {
-  const url = `${AUCTIONEER_URL}/user_intent`;
-  const response = await fetch(url, {
-    method: 'GET',
-    headers: {
-      'Content-Type': 'application/json',
-      Authorization: `Bearer ${jwtToken}`,
-    },
-  });
-
-  const data: ApiResponse<ApiUserOrders> = await response.json();
+/**
+ * Parameters for {@link fetchUserOrders}.
+ *
+ * The auctioneer resolves the wallets to query from the JWT claims and/or the `wallet`
+ * address, so at least one of `token`/`wallet` must be provided. `network` optionally
+ * restricts the results to a single chain.
+ */
+export interface FetchUserOrdersParams {
+  /**
+   * SIWE-issued JWT. Optional while the auctioneer skips JWT verification — when present,
+   * its wallet claims are queried in addition to `wallet`. Obtain it with
+   * `EVMSDK.authenticate()` (or the `fetchSiweMessage` + `fetchJWTToken` pair).
+   */
+  token?: string;
+  /** Wallet address to query. Required when no `token` is supplied. */
+  wallet?: string;
+  /** Restrict results to a single chain; omit to return orders on every network. */
+  network?: SupportedChain;
+}
 
-  if (!data.success) {
-    throw new Error(`Failed to fetch user orders: ${data.error}`);
+/**
+ * Fetches the orders owned by a wallet (and/or the wallets encoded in a SIWE-issued JWT).
+ *
+ * ⚠️ The auctioneer currently skips JWT verification, so the queried wallet may be passed
+ * directly via `wallet`. Once verification is restored, only wallets proved via SIWE (i.e.
+ * carried by a valid `token`) will be readable.
+ */
+export async function fetchUserOrders({ token, wallet, network }: FetchUserOrdersParams): Promise<ApiUserOrders> {
+  if (!token && !wallet) {
+    throw new Error('fetchUserOrders requires a `wallet` address or a SIWE-issued `token` (JWT)');
   }
 
-  return data.data!;
+  return new AuctioneerAPI(token).getUserOrders({ wallet, network });
 }

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

@@ -1,10 +1,25 @@
 import { AUCTIONEER_URL } from '../../../constants.js';
+import type { SupportedChain } from '../../../chains.js';
 import type { ApiResponse, ApiUserOrders } from '../../../types/api.js';
 
+/**
+ * Query filters for `GET /user_intent`.
+ *
+ * The auctioneer resolves the wallets to query from the (currently unvalidated) JWT claims
+ * and/or the `wallet` param; at least one source must be present. `network` optionally
+ * restricts results to a single chain — omit it to return orders on every network.
+ */
+export interface GetUserOrdersParams {
+  /** Wallet address to query. Combined with any wallet(s) carried by the JWT claims. */
+  wallet?: string;
+  /** Restrict results to a single chain. Serialized as its chain id (e.g. 8453). */
+  network?: SupportedChain;
+}
+
 export class AuctioneerAPI {
-  public aggregatedToken: string;
+  public aggregatedToken?: string;
 
-  constructor(aggregatedToken: string) {
+  constructor(aggregatedToken?: string) {
     this.aggregatedToken = aggregatedToken;
   }
 
@@ -12,14 +27,30 @@ export class AuctioneerAPI {
     this.aggregatedToken = token;
   }
 
-  public async getUserOrders() {
-    const url = `${AUCTIONEER_URL}/user_intent`;
+  public async getUserOrders(params: GetUserOrdersParams = {}) {
+    const query = new URLSearchParams();
+    if (params.wallet) {
+      query.set('wallet', params.wallet);
+    }
+    if (params.network !== undefined) {
+      query.set('network', String(params.network));
+    }
+
+    const queryString = query.toString();
+    const url = `${AUCTIONEER_URL}/user_intent${queryString ? `?${queryString}` : ''}`;
+
+    // JWT is optional while the auctioneer skips verification; only send the header when a
+    // token is present. Otherwise the wallet is resolved from the `wallet` param alone.
+    const headers: Record<string, string> = {
+      'Content-Type': 'application/json',
+    };
+    if (this.aggregatedToken) {
+      headers.Authorization = `Bearer ${this.aggregatedToken}`;
+    }
+
     const response = await fetch(url, {
       method: 'GET',
-      headers: {
-        'Content-Type': 'application/json',
-        Authorization: `Bearer ${this.aggregatedToken}`,
-      },
+      headers,
     });
 
     const data: ApiResponse<ApiUserOrders> = await response.json();

package/src/core/orders/common.ts

@@ -1,6 +1,8 @@
 import { IntentsOrderType } from '../../constants.js';
 import type { CrossChainOrderPrepared, SingleChainOrderPrepared } from '../../types/intent.js';
 
+export type StopLossType = 'FIXED' | 'TRAILING_ABSOLUTE' | 'TRAILING_PERCENT';
+
 export type ExtraTransfer = {
   /** Token address */
   token: string;