@shogun-sdk/intents-sdk 1.3.0 → 1.4.0

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;

package/src/core/orders/cross-chain.ts

@@ -10,7 +10,7 @@ import {
 } from '../../types/intent.js';
 import { CrossChainOrderValidator } from '../../utils/order-validator.js';
 import { Parsers } from '../../utils/parsers.js';
-import { type ExtraTransfer } from './common.js';
+import { type ExtraTransfer, type StopLossType } from './common.js';
 import type { ApiResponse } from '../../types/api.js';
 import { BaseSDK } from '../sdk.js';
 import { getEVMCrossChainOrderTypedData } from '../evm/order-signature.js';
@@ -40,8 +40,9 @@ export type CreateCrossChainOrderParams = {
   /** Extra transfers to be made */
   extraTransfers?: ExtraTransfer[];
 
-  /** Stop loss max out */
-  stopLossMaxOut?: bigint;
+  /** Stop loss */
+  stopLossType?: StopLossType;
+  stopLossTriggerPrice?: string;
   /** Take profit min out */
   takeProfitMinOut?: bigint;
 };
@@ -73,8 +74,9 @@ export class CrossChainOrder {
   public deadline: number;
   /** Extra transfers to be made */
   public extraTransfers?: ExtraTransfer[];
-  /** Stop loss max out */
-  public stopLossMaxOut?: bigint;
+  /** Stop loss */
+  public stopLossType?: StopLossType;
+  public stopLossTriggerPrice?: string;
   /** Take profit min out */
   public takeProfitMinOut?: bigint;
 
@@ -90,7 +92,8 @@ export class CrossChainOrder {
     this.minStablecoinAmount = params.minStablecoinAmount ?? 1n;
     this.deadline = params.deadline;
     this.extraTransfers = params.extraTransfers;
-    this.stopLossMaxOut = params.stopLossMaxOut;
+    this.stopLossType = params.stopLossType;
+    this.stopLossTriggerPrice = params.stopLossTriggerPrice;
     this.takeProfitMinOut = params.takeProfitMinOut;
   }
 
@@ -154,15 +157,16 @@ export class CrossChainOrder {
   private static async calculateAmountOutMin(
     input: CreateCrossChainOrderParams,
   ): Promise<{ minStablecoinAmount: bigint; destinationTokenMinAmount: bigint }> {
-    const { destinationTokenMinAmount, stopLossMaxOut, minStablecoinAmount } = input;
+    const { destinationTokenMinAmount, stopLossType, stopLossTriggerPrice, minStablecoinAmount } = input;
 
-    if (stopLossMaxOut !== undefined) {
+    if (stopLossType !== undefined && stopLossTriggerPrice !== undefined) {
       return {
         destinationTokenMinAmount: 1n,
         minStablecoinAmount: 1n,
       };
     }
 
+    // TODO: Change this
     if (!minStablecoinAmount || !destinationTokenMinAmount) {
       const quote = await QuoteProvider.getQuote({
         sourceChainId: input.sourceChainId,
@@ -196,6 +200,9 @@ export class CrossChainOrder {
       destinationAddress: this.destinationAddress,
       amountOutMin: this.destinationTokenMinAmount,
       extraTransfers: this.extraTransfers,
+      stopLossType: this.stopLossType,
+      stopLossTriggerPrice: this.stopLossTriggerPrice,
+      takeProfitMinOut: this.takeProfitMinOut,
     };
   }
 

package/src/core/orders/single-chain.ts

@@ -4,10 +4,13 @@ import type { ApiResponse } from '../../types/api.js';
 import type { SingleChainPreparedData, SingleChainUserIntentRequest } from '../../types/intent.js';
 import { SingleChainOrderValidator } from '../../utils/order-validator.js';
 import { QuoteProvider } from '../../utils/quote/aggregator.js';
+import { estimateAmountOut } from '../../utils/quote/pricing/estimate-amount-out.js';
+import { estimateExpensesInTokenOut } from '../../utils/quote/pricing/expenses.js';
+import { DEFAULT_COMMISSION_BPS, EVM_SINGLE_CHAIN_GAS_LIMIT, SINGLE_CHAIN_COMMISSION_DENOMINATOR } from '../../utils/quote/pricing/constants.js';
 import { getEVMSingleChainOrderTypedData } from '../evm/order-signature.js';
 import { BaseSDK } from '../sdk.js';
 import { getSolanaSingleChainOrderInstructions } from '../solana/order-instructions.js';
-import { type ExtraTransfer } from './common.js';
+import { type ExtraTransfer, type StopLossType } from './common.js';
 
 export type CreateSingleChainOrderParams = {
   chainId: SupportedChain;
@@ -19,7 +22,8 @@ export type CreateSingleChainOrderParams = {
   extraTransfers?: ExtraTransfer[];
   deadline: number;
 
-  stopLossMaxOut?: bigint;
+  stopLossType?: StopLossType;
+  stopLossTriggerPrice?: string;
   takeProfitMinOut?: bigint;
 };
 
@@ -35,7 +39,8 @@ export class SingleChainOrder {
   public destinationAddress: string;
   public extraTransfers?: ExtraTransfer[];
   public deadline: number;
-  public stopLossMaxOut?: bigint;
+  public stopLossType?: StopLossType;
+  public stopLossTriggerPrice?: string;
   public takeProfitMinOut?: bigint;
 
   private constructor(params: CreateSingleChainOrderParams & { user: string }) {
@@ -48,7 +53,8 @@ export class SingleChainOrder {
     this.destinationAddress = params.destinationAddress;
     this.extraTransfers = params.extraTransfers;
     this.deadline = params.deadline;
-    this.stopLossMaxOut = params.stopLossMaxOut;
+    this.stopLossType = params.stopLossType;
+    this.stopLossTriggerPrice = params.stopLossTriggerPrice;
     this.takeProfitMinOut = params.takeProfitMinOut;
   }
 
@@ -104,22 +110,33 @@ export class SingleChainOrder {
   }
 
   private static async calculateAmountOutMin(input: CreateSingleChainOrderParams): Promise<bigint> {
-    const { amountOutMin, stopLossMaxOut } = input;
+    const { amountOutMin, stopLossType, stopLossTriggerPrice } = input;
 
     const scenario = this.getSingleChainOrderScenario({
       hasAmountOutMin: !!amountOutMin,
-      hasStopLoss: !!stopLossMaxOut,
+      hasStopLoss: !!stopLossType && !!stopLossTriggerPrice,
     });
 
     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; // Add 7% reduced fixed amount to cover fees
+        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),
+          }),
+        ]);
+
+        // Worst-case output already carries provider slippage; never use the nominal amountOut.
+        const swapOutput = quote.amountOutMin ?? quote.amountOut;
+        return estimateAmountOut(swapOutput, DEFAULT_COMMISSION_BPS, expenses, SINGLE_CHAIN_COMMISSION_DENOMINATOR);
       }
 
       case 'USE_PROVIDED_AMOUNT':

package/src/core/sdk.ts

@@ -4,6 +4,7 @@ import type { ApiResponse } from '../types/api.js';
 import type {
   CrossChainOrderPrepared,
   CrossChainUserIntentRequest,
+  DcaCrossChainUserIntentRequest,
   DcaSingleChainOrderPrepared,
   DcaSingleChainUserIntentRequest,
   SingleChainOrderPrepared,
@@ -32,6 +33,7 @@ export abstract class BaseSDK {
       body,
     });
 
+    console.debug(`url`, url, `body`, body)
     if (!response.ok) {
       const errorJson: ApiResponse = await response.json();
       const mainError = errorJson.error;
@@ -121,4 +123,13 @@ export abstract class BaseSDK {
   public static async validateDcaSingleChainOrder(intentRequest: DcaSingleChainUserIntentRequest): Promise<void> {
     return BaseSDK.validateOrder(intentRequest, '/validate_intent/single_chain/dca_order');
   }
+
+  public static async validateDcaCrossChainOrder(intentRequest: DcaCrossChainUserIntentRequest): Promise<void> {
+    return BaseSDK.validateOrder(intentRequest, '/validate_intent/cross_chain/dca_order');
+  }
+
+  public static async sendDcaCrossChainOrder(intentRequest: DcaCrossChainUserIntentRequest): Promise<ApiResponse> {
+    const body = JSON.stringify(intentRequest, Parsers.bigIntReplacer);
+    return BaseSDK.makeRequest(`${AUCTIONEER_URL}/user_intent/cross_chain/dca_order`, body);
+  }
 }

package/src/core/solana/cancel-order.ts

@@ -86,13 +86,14 @@ export async function cancelSingleChainOrderInstructions(
   }
 
   const cancelLimitOrderIx = getCancelLimitOrderInstruction({
-    user: createNoopSigner(orderUserAddress),
     order: orderId,
     guard: guardAddress,
     tokenInMint: chainOrder.data.tokenInMint,
     userTokenInAccount: userTokenInAccount.address,
     guardTokenInAccount: guardProgramAccount,
     tokenInProgram: tokenMintProgram.programAddress,
+    signer: createNoopSigner(orderUserAddress),
+    user: orderUserAddress
   });
 
   instructions.push(cancelLimitOrderIx);
@@ -245,7 +246,7 @@ export async function cancelCrossChainOrderInstructions(
 
   // Create the cancel order instruction
   const cancelOrderIx = getCancelOrderInstruction({
-    user: createNoopSigner(orderUserAddress),
+    user: orderUserAddress,
     order: orderId,
     guard: guardAddress,
     recoveredTokenMint: recoverTokenMint,
@@ -256,6 +257,7 @@ export async function cancelCrossChainOrderInstructions(
     userCollateralTokenAccount: userCollateralTokenAccount,
     guardCollateralTokenAccount: guardCollateralTokenAccount,
     collateralTokenProgram: collateralTokenMintProgram.programAddress,
+    signer: createNoopSigner(orderUserAddress)
   });
 
   instructions.push(cancelOrderIx);

package/src/core/solana/client.ts

@@ -5,7 +5,7 @@ import {
   type RpcSubscriptions,
   type SolanaRpcApiMainnet,
   type SolanaRpcSubscriptionsApi,
-  sendAndConfirmTransactionFactory
+  sendAndConfirmTransactionFactory,
 } from '@solana/kit';
 import type { SolanaConfig } from '../../config.js';
 

package/src/core/solana/dca/cancel-order.ts

@@ -76,7 +76,8 @@ export async function cancelDcaSingleChainOrderInstructions(
   }
 
   const cancelLimitOrderIx = getCancelDcaOrderInstruction({
-    user: createNoopSigner(orderUserAddress),
+    user: orderUserAddress,
+    signer: createNoopSigner(orderUserAddress),
     order: orderId,
     guard: guardAddress,
     tokenInMint: chainOrder.data.tokenInMint,