@shogun-sdk/intents-sdk 1.0.2 → 1.1.0

package/src/core/sui/order-transaction.ts

@@ -1,26 +1,24 @@
 import { Transaction } from '@mysten/sui/transactions';
-import { normalizeSuiObjectId, SUI_TYPE_ARG } from '@mysten/sui/utils';
+import { normalizeSuiObjectId } from '@mysten/sui/utils';
 
 import { ChainID } from '../../chains.js';
 import {
-  SRC_CHAIN_GUARD,
+  CROSS_CHAIN_GUARD_ADDRESSES,
+  NATIVE_SUI_TOKEN_ADDRESS,
   SUI_GUARD_COLLATERAL_TYPE,
   SUI_GUARD_STABLECOIN_TYPE,
   SUI_PACKAGE_ID,
 } from '../../constants.js';
 import { ValidationError } from '../../errors/index.js';
-import type { Order } from '../order.js';
 import { createSuiClient } from './client.js';
-import { BaseSDK } from '../sdk.js';
-import type { ApiResponse } from '../../types/api.js';
-import type { PreparedOrder } from '../../types/intent.js';
+import type { CrossChainOrder } from '../orders/cross-chain.js';
 
 /**
  * Generates Sui order transaction for creating an order
  * @param order The order to generate transaction for
  * @returns Object containing the transaction
  */
-export async function getSuiOrderTransaction(order: Order): Promise<Transaction> {
+export async function getSuiOrderTransaction(order: CrossChainOrder): Promise<Transaction> {
   const userAddress = order.user;
   const client = createSuiClient();
   const coins = await client.getCoins({
@@ -28,7 +26,7 @@ export async function getSuiOrderTransaction(order: Order): Promise<Transaction>
     coinType: order.sourceTokenAddress,
   });
 
-  const guardAddress = SRC_CHAIN_GUARD[ChainID.Sui];
+  const guardAddress = CROSS_CHAIN_GUARD_ADDRESSES[ChainID.Sui];
 
   const sourceTokenInCoins = coins.data.sort((a, b) => Number(b.balance) - Number(a.balance));
 
@@ -44,7 +42,8 @@ export async function getSuiOrderTransaction(order: Order): Promise<Transaction>
     );
   }
 
-  const spendingGasCoin = normalizeSuiObjectId(order.sourceTokenAddress) === normalizeSuiObjectId(SUI_TYPE_ARG);
+  const spendingGasCoin =
+    normalizeSuiObjectId(order.sourceTokenAddress) === normalizeSuiObjectId(NATIVE_SUI_TOKEN_ADDRESS);
 
   const tx = new Transaction();
   const coinInArg = spendingGasCoin ? tx.gas : sourceTokenInCoins[0]!.coinObjectId;
@@ -66,11 +65,12 @@ export async function getSuiOrderTransaction(order: Order): Promise<Transaction>
     module: 'source_chain_guard',
     function: 'create_order',
     arguments: [
-      tx.object(guardAddress),
-      coinIn,
-      tx.pure.u64(order.minStablecoinAmount),
-      tx.pure.u64(order.deadline * 1000), // Convert to milliseconds
-      tx.pure.vector('u8', order.executionDetailsHashToBytes()),
+      tx.object(guardAddress), // arg0: &Guard<T0, T2>
+      coinIn, // arg1: Coin<T1>
+      tx.pure.u64(order.minStablecoinAmount), // arg2: min_stablecoins_amount
+      tx.pure.u64(order.deadline * 1000), // arg3: deadline (converted to milliseconds)
+      tx.pure.vector('u8', order.executionDetailsHashToBytes()), // arg4: execution_details_hash
+      tx.object.clock(), // arg5: &Clock
     ],
     typeArguments: [SUI_GUARD_COLLATERAL_TYPE, order.sourceTokenAddress, SUI_GUARD_STABLECOIN_TYPE],
   });
@@ -79,20 +79,3 @@ export async function getSuiOrderTransaction(order: Order): Promise<Transaction>
 
   return tx;
 }
-
-export async function sendSuiRequest({
-  order,
-  transactionDigest,
-}: {
-  order: Order;
-  transactionDigest: string;
-}): Promise<ApiResponse> {
-  const preparedOrder: PreparedOrder = {
-    order,
-    preparedData: {
-      transactionHash: transactionDigest,
-    },
-  };
-
-  return BaseSDK.sendOrder(preparedOrder);
-}

package/src/core/sui/sdk.ts

@@ -1,13 +1,16 @@
 import type { SuiClient } from '@mysten/sui/client';
 import { Ed25519Keypair } from '@mysten/sui/keypairs/ed25519';
-
 import type { SuiConfig } from '../../config.js';
-import { OrderCreationError } from '../../errors/index.js';
-import type { PreparedOrder } from '../../types/intent.js';
-import { Order } from '../order.js';
 import { BaseSDK } from '../sdk.js';
 import { createSuiClient } from './client.js';
 import { getSuiOrderTransaction } from './order-transaction.js';
+import { getSuiCancelCrossChainOrder } from './cancel.js';
+import type { CrossChainOrderPrepared, SingleChainOrderPrepared } from '../../types/intent.js';
+import type { CrossChainOrder } from '../orders/cross-chain.js';
+import type { ApiUserOrders } from '../../types/api.js';
+import { fetchJWTToken, fetchSiweMessage } from '../../auth/siwe.js';
+import { fetchUserOrders } from '../orders/api/fetch.js';
+import { ChainID } from '../../chains.js';
 
 /**
  * Sui-specific SDK implementation
@@ -17,14 +20,11 @@ import { getSuiOrderTransaction } from './order-transaction.js';
  * Supports cross-chain swaps from Sui to other supported chains.
  */
 export class SuiSDK extends BaseSDK {
-  protected override cancelOrderInternal(): Promise<string> {
-    throw new Error('Method not implemented.');
-  }
-
   /** Configuration for Sui connection and authentication */
   private readonly config: SuiConfig;
   /** Client for Sui RPC interactions and transaction handling */
   private client: SuiClient;
+  private token?: string;
 
   /**
    * Creates a new instance of the Sui SDK
@@ -60,6 +60,54 @@ export class SuiSDK extends BaseSDK {
     return Ed25519Keypair.fromSecretKey(this.config.privateKey);
   }
 
+  protected override prepareSingleChainOrder(): Promise<SingleChainOrderPrepared> {
+    throw new Error('Single-chain orders are not supported on Sui');
+  }
+
+  public async authenticate(token?: string): Promise<string> {
+    const wallet = await this.getUserAddress();
+
+    const response = await fetchSiweMessage({
+      chainId: ChainID.Sui,
+      wallet,
+    });
+
+    const message = response.data!;
+
+    const keypair = this.getKeyPair();
+
+    const messageBytes = new TextEncoder().encode(message);
+
+    const { signature } = await keypair.signPersonalMessage(messageBytes);
+
+    const jwt = await fetchJWTToken(
+      {
+        message,
+        signature,
+      },
+      token,
+    );
+
+    const newToken = jwt.data!;
+
+    return newToken;
+  }
+
+  public setToken(token: string) {
+    this.token = token;
+
+    return this;
+  }
+
+  public override async getOrders(): Promise<ApiUserOrders> {
+    if (!this.token) {
+      throw new Error('No token provided');
+    }
+
+    const orders = await fetchUserOrders(this.token);
+
+    return orders;
+  }
   /**
    * Prepares a Sui order for submission
    *
@@ -73,27 +121,42 @@ export class SuiSDK extends BaseSDK {
    * @returns Promise resolving to a prepared order with Sui-specific data
    * @protected
    */
-  protected async prepareOrder(order: Order): Promise<PreparedOrder> {
-    try {
-      const signer = this.getKeyPair();
-
-      const transaction = await getSuiOrderTransaction(order);
-
-      const tx = await this.client.signAndExecuteTransaction({
-        signer,
-        transaction,
-      });
-
-      await this.client.waitForTransaction({ digest: tx.digest });
-
-      return {
-        order,
-        preparedData: {
-          transactionHash: tx.digest,
-        },
-      };
-    } catch (error) {
-      throw new OrderCreationError('Failed to prepare Sui order', error);
-    }
+  protected async prepareCrossChainOrder(order: CrossChainOrder): Promise<CrossChainOrderPrepared> {
+    const signer = this.getKeyPair();
+
+    const transaction = await getSuiOrderTransaction(order);
+
+    const tx = await this.client.signAndExecuteTransaction({
+      signer,
+      transaction,
+    });
+
+    await this.client.waitForTransaction({ digest: tx.digest });
+
+    return {
+      order,
+      preparedData: {
+        transactionHash: tx.digest,
+      },
+    };
+  }
+
+  public async cancelCrossChainOrder(orderId: string): Promise<string> {
+    const signer = this.getKeyPair();
+
+    const transaction = await getSuiCancelCrossChainOrder(orderId);
+
+    const sender = await this.getUserAddress();
+
+    transaction.setSender(sender);
+
+    const tx = await this.client.signAndExecuteTransaction({
+      signer,
+      transaction,
+    });
+
+    await this.client.waitForTransaction({ digest: tx.digest });
+
+    return tx.digest;
   }
 }

package/src/core/sui/validator.ts

@@ -25,8 +25,12 @@ export class SuiValidator extends BaseValidator {
     return 'Sui';
   }
 
-  public async chainSpecificValidation(): Promise<void> {
+  public async validateCrossChainOrderFeasability(): Promise<void> {
     // No chain-specific validation implemented for now for Sui
     return;
   }
+
+  override validateSingleChainOrderFeasability(): Promise<void> {
+    return Promise.resolve();
+  }
 }

package/src/errors/index.ts

@@ -32,29 +32,6 @@ export class BaseError extends Error {
   }
 }
 
-// Chain-specific error classes
-export class EVMError extends BaseError {
-  constructor(message: string, cause?: unknown) {
-    super(message, cause);
-    Object.setPrototypeOf(this, EVMError.prototype);
-  }
-}
-
-export class SolanaError extends BaseError {
-  constructor(message: string, cause?: unknown) {
-    super(message, cause);
-    Object.setPrototypeOf(this, SolanaError.prototype);
-  }
-}
-
-export class SuiError extends BaseError {
-  constructor(message: string, cause?: unknown) {
-    super(message, cause);
-    Object.setPrototypeOf(this, SuiError.prototype);
-  }
-}
-
-// Specific error types
 export class ValidationError extends BaseError {
   constructor(message: string, cause?: unknown) {
     super(message, cause);
@@ -62,13 +39,6 @@ export class ValidationError extends BaseError {
   }
 }
 
-export class OrderCreationError extends BaseError {
-  constructor(message: string, cause?: unknown) {
-    super(message, cause);
-    Object.setPrototypeOf(this, OrderCreationError.prototype);
-  }
-}
-
 export class NetworkError extends BaseError {
   constructor(message: string, cause?: unknown) {
     super(message, cause);
@@ -83,19 +53,13 @@ export class InsufficientBalanceError extends BaseError {
   }
 }
 
-export class CalculateAmountError extends BaseError {
-  constructor(message: string, cause?: unknown) {
-    super(message, cause);
-    Object.setPrototypeOf(this, CalculateAmountError.prototype);
-  }
-}
-
 export class InsufficientAllowanceError extends BaseError {
   constructor(message: string, cause?: unknown) {
     super(message, cause);
     Object.setPrototypeOf(this, InsufficientAllowanceError.prototype);
   }
 }
+
 export function handleError(error: unknown): BaseError {
   if (error instanceof BaseError) {
     return error;

package/src/index.ts

@@ -1,21 +1,42 @@
-export { ChainID, ChainType, SupportedChains } from './chains.js';
-export type { SupportedEvmChain } from './chains.js';
+export { ChainID, ChainType, SupportedChains, isSupportedChain, chainIdToChainTypeMap, isEvmChain } from './chains.js';
+export type { SupportedEvmChain, SupportedChain } from './chains.js';
 
 export type { EVMConfig, SolanaConfig, SuiConfig } from './config.js';
 export { EVMSDK } from './core/evm/sdk.js';
-export { Order } from './core/order.js';
 export { SolanaSDK } from './core/solana/sdk.js';
 export { SuiSDK } from './core/sui/sdk.js';
+export { CrossChainOrder } from './core/orders/cross-chain.js';
+export type { CreateCrossChainOrderParams } from './core/orders/cross-chain.js';
+export { SingleChainOrder } from './core/orders/single-chain.js';
+export type { CreateSingleChainOrderParams } from './core/orders/single-chain.js';
+
+export { fetchUserOrders } from './core/orders/api/fetch.js';
+export { type FetchJWTParams, type FetchSiweMessageParams, fetchJWTToken, fetchSiweMessage } from './auth/siwe.js';
 export { ValidationError } from './errors/index.js';
-export {
-  calculateAmounts,
-  chainIdToDefiLlamaChainMap,
-  createDefiLlamaCoinKey,
-  getCoinFromResponse,
-  getTokensData,
-} from './utils/defillama.js';
+export { type ApiCrossChainOrder, type ApiResponse, type ApiSingleChainOrder, type ApiUserOrders, type ChainOrderStatus, isErrorApiResponse, isSuccessApiResponse } from './types/api.js';
+export { calculateAmounts, getCoinFromResponse, getTokensData } from './utils/defillama.js';
 export type { DefiLlamaCoinData, DefiLlamaTokensResponse } from './utils/defillama.js';
-export type { CreateOrderParams } from './types/intent.js';
-export { getEvmOrderTypedData, sendEvmRequest } from './core/evm/order-signature.js';
-export { getSolanaOrderInstructions, sendSolanaRequest } from './core/solana/order-instructions.js';
-export { getSuiOrderTransaction, sendSuiRequest } from './core/sui/order-transaction.js';
+export {
+  getCancelCrossChainOrderRawData,
+  getCancelSingleChainOrderRawData,
+  type CancelSingleChainOrderParams,
+  type CancelCrossChainOrderParams,
+  getInvalidateNoncesRawData,
+} from './core/evm/cancel-order.js';
+export { getEVMCrossChainOrderTypedData, getEVMSingleChainOrderTypedData } from './core/evm/order-signature.js';
+
+export {
+  getSolanaCrossChainOrderInstructions,
+  getSolanaSingleChainOrderInstructions,
+} from './core/solana/order-instructions.js';
+export {
+  cancelCrossChainOrderInstructionsAsBytes,
+  cancelSingleChainOrderInstructionsAsBytes,
+} from './core/solana/cancel-order.js';
+export { getSuiOrderTransaction } from './core/sui/order-transaction.js';
+export { getSuiCancelCrossChainOrder } from './core/sui/cancel.js';
+
+export { QuoteProvider } from './utils/quote/aggregator.js';
+export type { QuoteResponse } from './utils/quote/aggregator.js';
+
+export { CROSS_CHAIN_GUARD_ADDRESSES, SINGLE_CHAIN_GUARD_ADDRESSES, PERMIT2_ADDRESS } from './constants.js';

package/src/types/api.ts

@@ -1,9 +1,78 @@
-export type ApiResponse = {
-  success: boolean;
-  code: number;
+import type { ExtraTransfer } from '../core/orders/common.js';
 
-  data?: unknown;
+export type ChainOrderStatus = 'Auction' | 'NoBids' | 'Executing' | 'Fulfilled' | 'Cancelled' | 'Outdated';
+
+export type ApiCrossChainOrder = {
+  orderId: string;
+  // Flattened fields from the API response
+  user: string;
+  srcChainId: number;
+  tokenIn: string;
+  minStablecoinsAmount: string;
+  destChainId: number;
+  tokenOut: string;
+  amountOutMin: string;
+  destinationAddress: string;
+  extraTransfers?: ExtraTransfer[];
+  deadline: number;
+  executionDetailsHash: string;
+  amountIn: string;
+  // Cross-chain specific fields
+  executionDetails: string;
+  orderCreationTime: number;
+  orderStatus: ChainOrderStatus;
+  tokensInWereSwappedToStablecoins: boolean;
+  lockedStablecoins: string;
+  nonce?: string;
+  orderFulfillmentTimestamp?: number;
+  transactionHash?: string;
+  amountOut?: string;
+};
 
+export type ApiSingleChainOrder = {
+  orderId: string;
+  // Flattened fields from the API response
+  user: string;
+  chainId: number;
+  tokenIn: string;
+  tokenOut: string;
+  amountOutMin: string;
+  destinationAddress: string;
+  extraTransfers?: ExtraTransfer[];
+  deadline: number;
+  amountIn: string;
+  // Single-chain specific fields
+  orderCreationTime: number;
+  orderStatus: ChainOrderStatus;
+  nonce?: string;
+  orderFulfillmentTimestamp?: number;
+  transactionHash?: string;
+  amountOut?: string;
+};
+
+export type ApiUserOrders = {
+  singleChainLimitOrders: ApiSingleChainOrder[];
+  crossChainLimitOrders: ApiCrossChainOrder[];
+};
+
+export type ValidResponseData = ApiUserOrders | string | null;
+
+export type ApiResponse<T extends ValidResponseData = ValidResponseData> = {
+  success: boolean;
+  code: number;
+  data?: T;
   error?: unknown;
   extra_error_data?: unknown;
 };
+
+export function isSuccessApiResponse<T extends ValidResponseData>(
+  response: ApiResponse<T>,
+): response is ApiResponse<T> & { success: true; data: T } {
+  return response.success;
+}
+
+export function isErrorApiResponse<T extends ValidResponseData>(
+  response: ApiResponse<T>,
+): response is ApiResponse<T> & { success: false; error: unknown } {
+  return !response.success;
+}

package/src/types/intent.ts

@@ -1,35 +1,7 @@
 import type { SupportedChain } from '../chains.js';
-import type { ExtraTransfer, Order } from '../core/order.js';
-
-/**
- * Parameters for creating a cross-chain order
- * Used as input for the createOrder and createAndSendOrder methods
- */
-export type CreateOrderParams = {
-  /** Chain ID where tokens will be sent from */
-  sourceChainId: SupportedChain;
-  /** Token address on the source chain to be swapped */
-  sourceTokenAddress: string;
-  /** Amount of source tokens to swap, in smallest units (e.g., Wei for ETH) */
-  sourceTokenAmount: bigint;
-
-  /** Chain ID where tokens will be received */
-  destinationChainId: SupportedChain;
-  /** Token address on the destination chain to receive */
-  destinationTokenAddress: string;
-  /** Minimum amount of destination tokens to receive, in smallest units */
-  destinationTokenMinAmount?: bigint;
-  /** Recipient wallet address on the destination chain */
-  destinationAddress: string;
-
-  /** Minimum amount of stablecoins in the intermediate swap, in smallest units */
-  minStablecoinAmount?: bigint;
-  /** Timestamp (in seconds) after which the order expires */
-  deadline: number;
-
-  /** Extra Transfers */
-  extraTransfers?: ExtraTransfer[];
-};
+import type { CrossChainOrder } from '../core/orders/cross-chain.js';
+import type { ExtraTransfer } from '../core/orders/common.js';
+import type { SingleChainOrder } from '../core/orders/single-chain.js';
 
 /**
  * Details required to execute the order on the destination chain
@@ -48,15 +20,10 @@ export type ExecutionDetails = {
   extraTransfers?: ExtraTransfer[];
 };
 
-/** Hex string with 0x prefix, used for various hashes */
 export type Hash = `0x${string}`;
 /** Hash of execution details, used to verify order integrity across chains */
 export type ExecutionDetailsHash = Hash;
 
-/**
- * EVM-specific data required for prepared orders
- * Contains the signature and nonce for Permit2 allowance
- */
 export type EvmPreparedData = {
   /** Random nonce for Permit2 signature, prevents replay attacks */
   nonce: string;
@@ -64,19 +31,11 @@ export type EvmPreparedData = {
   signature: string | Hash;
 };
 
-/**
- * Sui-specific data required for prepared orders
- * Contains the transaction hash of the order creation transaction
- */
 export type SuiPreparedData = {
   /** Transaction hash of the successful order creation transaction */
   transactionHash: string;
 };
 
-/**
- * Solana-specific data required for prepared orders
- * Contains the public key of the created order account
- */
 export type SolanaPreparedData = {
   /** Public key of the created order account on Solana */
   orderPubkey: string;
@@ -101,13 +60,12 @@ export type SourceChainData = {
   deadline: number;
   /** Hash of execution details for cross-chain verification */
   executionDetailsHash: ExecutionDetailsHash;
+  stopLossMaxOut?: bigint;
+  takeProfitMinOut?: bigint;
+  extraTransfers?: ExtraTransfer[];
 };
 
-/**
- * Complete user intent request sent to the auctioneer service
- * Contains all the information needed to execute the cross-chain swap
- */
-export type UserIntentRequest = {
+export type CrossChainUserIntentRequest = {
   /** Generic data common to all chains */
   genericData: SourceChainData;
   /** JSON-stringified execution details for the destination chain */
@@ -123,21 +81,42 @@ export type UserIntentRequest = {
   };
 };
 
-/**
- * Union type of all chain-specific prepared data
- * The actual type depends on the source chain
- */
+export type SingleChainUserIntentRequest = {
+  genericData: SingleChainOrder;
+  chainSpecificData: {
+    EVM?: EvmPreparedData;
+    Solana?: SolanaPreparedData;
+    Sui?: SolanaPreparedData;
+  };
+};
+
 export type ChainPreparedData = EvmPreparedData | SuiPreparedData | SolanaPreparedData;
 
-/**
- * Fully prepared order ready for submission to the auctioneer
- * Contains both the order details and chain-specific prepared data
- */
-export type PreparedOrder = {
-  /** The original order with all cross-chain details */
-  order: Order;
-  /** Chain-specific data needed for order execution */
+export type CrossChainOrderPrepared = {
+  order: CrossChainOrder;
   preparedData: ChainPreparedData;
-  /** Hash related to the start order execution */
-  // txHash: string // TODO: Think if we need this
+};
+
+export type SingleChainEVMPreparedData = {
+  nonce: string;
+  signature: string | Hash;
+};
+
+export type SingleChainSolanaPreparedData = {
+  secretNumber: string;
+  orderPubkey: string;
+};
+
+export type SingleChainSuiPreparedData = {
+  transactionHash: string;
+};
+
+export type SingleChainPreparedData =
+  | SingleChainEVMPreparedData
+  | SingleChainSolanaPreparedData
+  | SingleChainSuiPreparedData;
+
+export type SingleChainOrderPrepared = {
+  order: SingleChainOrder;
+  preparedData: SingleChainPreparedData;
 };

package/src/utils/base-validator.ts

@@ -1,4 +1,5 @@
-import type { OrderInput } from '../core/order.js';
+import type { CreateCrossChainOrderParams } from '../core/orders/cross-chain.js';
+import type { CreateSingleChainOrderParams } from '../core/orders/single-chain.js';
 import { ValidationError } from '../errors/index.js';
 import type { IChainValidator } from './order-validator.js';
 
@@ -11,26 +12,43 @@ export abstract class BaseValidator implements IChainValidator {
   abstract isValidTokenAddress(tokenAddress: string): boolean;
   abstract isValidAmount(amount: bigint): boolean;
   protected abstract getChainName(): string;
-  abstract chainSpecificValidation(order: OrderInput): Promise<void>;
+  abstract validateCrossChainOrderFeasability(order: CreateCrossChainOrderParams & { user: string }): Promise<void>;
+  abstract validateSingleChainOrderFeasability(order: CreateSingleChainOrderParams & { user: string }): Promise<void>;
 
   /**
    * Validate source chain specific parameters of the order
    */
-  async validateSourceChain(order: OrderInput): Promise<void> {
-    this.validateAddress(order.user);
+  async validateSourceChain(order: CreateCrossChainOrderParams & { user: string }): Promise<void> {
     this.validateTokenAddress(order.sourceTokenAddress);
     this.validateAmount(order.sourceTokenAmount);
-    this.validateAmount(order.minStablecoinAmount);
-    await this.chainSpecificValidation(order);
+    this.validateAmount(order.minStablecoinAmount ?? 1n);
+    await this.validateCrossChainOrderFeasability({ ...order, user: order.user });
+  }
+
+  async validateSingleChainOrder(order: CreateSingleChainOrderParams & { user: string }): Promise<void> {
+    this.validateTokenAddress(order.tokenIn);
+    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);
+    }
+
+    await this.validateSingleChainOrderFeasability(order);
   }
 
   /**
    * Validate destination chain specific parameters of the order
    */
-  validateDestinationChain(order: OrderInput): void {
+  validateDestinationChain(order: CreateCrossChainOrderParams): void {
     this.validateAddress(order.destinationAddress);
     this.validateTokenAddress(order.destinationTokenAddress);
-    this.validateAmount(order.destinationTokenMinAmount);
+    this.validateAmount(order.destinationTokenMinAmount ?? 1n);
 
     if (order.extraTransfers) {
       for (const extraTransfer of order.extraTransfers) {