@luxexchange/lx 1.0.0

package/src/features/transactions/cancel/cancelOrderFactory.test.ts

@@ -0,0 +1,327 @@
+// Mock the logger to suppress debug logs during tests
+import '@luxfi/utilities/src/logger/mocks'
+import { BigNumber } from '@ethersproject/bignumber'
+import {
+  CosignedPriorityOrder,
+  CosignedV2DutchOrder,
+  CosignedV3DutchOrder,
+  DutchOrder,
+  getCancelMultipleParams,
+  getCancelSingleParams,
+} from '@uniswap/uniswapx-sdk'
+import { TradingApi } from '@luxexchange/api'
+import { UniverseChainId } from '@luxexchange/lx/src/features/chains/types'
+import {
+  buildBatchCancellation,
+  buildSingleCancellation,
+  OrderCancellationParams,
+} from '@luxexchange/lx/src/features/transactions/cancel/cancelOrderFactory'
+import { createPermit2Contract } from '@luxexchange/lx/src/features/transactions/utils/permit2'
+import type { Mock } from 'vitest'
+
+// Mock the dex-sdk functions
+vi.mock('@uniswap/uniswapx-sdk', async (importOriginal) => {
+  const actual = await importOriginal<typeof import('@uniswap/uniswapx-sdk')>()
+  return {
+    ...actual,
+    getCancelSingleParams: vi.fn(),
+    getCancelMultipleParams: vi.fn(),
+    CosignedV2DutchOrder: {
+      parse: vi.fn(),
+    },
+    CosignedV3DutchOrder: {
+      parse: vi.fn(),
+    },
+    CosignedPriorityOrder: {
+      parse: vi.fn(),
+    },
+    DutchOrder: {
+      parse: vi.fn(),
+    },
+  }
+})
+
+// Mock the permit2 contract creation
+vi.mock('lx/src/features/transactions/utils/permit2', () => ({
+  createPermit2Contract: vi.fn(),
+}))
+
+describe('cancelOrderFactory', () => {
+  const mockNonce = BigNumber.from('12345')
+  const mockFrom = '0x1234567890abcdef'
+  const chainId = UniverseChainId.Mainnet
+
+  const mockPermit2 = {
+    populateTransaction: {
+      invalidateUnorderedNonces: vi.fn().mockResolvedValue({
+        to: '0xpermit2address',
+        data: '0xcanceldata',
+        value: '0x0',
+      }),
+    },
+  }
+
+  beforeEach(() => {
+    // Reset all mocks
+    vi.clearAllMocks()
+
+    // Setup mock for permit2 creation
+    ;(createPermit2Contract as Mock).mockReturnValue(mockPermit2)
+
+    // Setup default mock behavior
+    const getCancelSingleParamsMock = getCancelSingleParams as Mock
+    const getCancelMultipleParamsMock = getCancelMultipleParams as Mock
+    getCancelSingleParamsMock.mockReturnValue({ word: '0x123', mask: '0x456' })
+    getCancelMultipleParamsMock.mockReturnValue([{ word: '0x789', mask: '0xabc' }])
+
+    const mockParsedOrder = {
+      info: { nonce: mockNonce },
+    }
+    const cosignedV2Parse = CosignedV2DutchOrder.parse as Mock
+    const cosignedV3Parse = CosignedV3DutchOrder.parse as Mock
+    const cosignedPriorityParse = CosignedPriorityOrder.parse as Mock
+    const dutchOrderParse = DutchOrder.parse as Mock
+    cosignedV2Parse.mockReturnValue(mockParsedOrder)
+    cosignedV3Parse.mockReturnValue(mockParsedOrder)
+    cosignedPriorityParse.mockReturnValue(mockParsedOrder)
+    dutchOrderParse.mockReturnValue(mockParsedOrder)
+  })
+
+  describe('buildSingleCancellation', () => {
+    const mockOrder: OrderCancellationParams = {
+      encodedOrder: '0xencodedorder',
+      routing: TradingApi.Routing.DUTCH_V2,
+      chainId,
+      orderHash: '0xhash',
+    }
+
+    it('should build a single cancellation transaction', async () => {
+      const result = await buildSingleCancellation(mockOrder, mockFrom)
+
+      expect(result).toEqual({
+        to: '0xpermit2address',
+        data: '0xcanceldata',
+        value: '0x0',
+        from: mockFrom,
+        chainId,
+      })
+
+      expect(createPermit2Contract).toHaveBeenCalledTimes(1)
+      expect(getCancelSingleParams).toHaveBeenCalledWith(mockNonce)
+      expect(mockPermit2.populateTransaction.invalidateUnorderedNonces).toHaveBeenCalledWith('0x123', '0x456')
+    })
+
+    it('should return null when order parsing fails', async () => {
+      const cosignedV2Parse = CosignedV2DutchOrder.parse as Mock
+      cosignedV2Parse.mockImplementationOnce(() => {
+        throw new Error('Parse error')
+      })
+
+      const result = await buildSingleCancellation(mockOrder, mockFrom)
+      expect(result).toBeNull()
+    })
+
+    it('should handle different routing types', async () => {
+      const orderTypes = [
+        { routing: TradingApi.Routing.DUTCH_V2, parser: 'CosignedV2DutchOrder' },
+        { routing: TradingApi.Routing.DUTCH_V3, parser: 'CosignedV3DutchOrder' },
+        { routing: TradingApi.Routing.PRIORITY, parser: 'CosignedPriorityOrder' },
+        { routing: TradingApi.Routing.DUTCH_LIMIT, parser: 'DutchOrder' },
+      ]
+
+      for (const { routing, parser } of orderTypes) {
+        const order = { ...mockOrder, routing }
+        await buildSingleCancellation(order, mockFrom)
+
+        let parseMethod: Mock
+        switch (parser) {
+          case 'CosignedV2DutchOrder':
+            parseMethod = CosignedV2DutchOrder.parse as Mock
+            break
+          case 'CosignedV3DutchOrder':
+            parseMethod = CosignedV3DutchOrder.parse as Mock
+            break
+          case 'CosignedPriorityOrder':
+            parseMethod = CosignedPriorityOrder.parse as Mock
+            break
+          case 'DutchOrder':
+            parseMethod = DutchOrder.parse as Mock
+            break
+          default:
+            throw new Error(`Unknown parser: ${parser}`)
+        }
+
+        expect(parseMethod).toHaveBeenCalledWith(order.encodedOrder, chainId)
+      }
+    })
+
+    it('should return null when nonce extraction fails', async () => {
+      const cosignedV2Parse = CosignedV2DutchOrder.parse as Mock
+      cosignedV2Parse.mockReturnValue({ info: {} }) // Missing nonce
+
+      const result = await buildSingleCancellation(mockOrder, mockFrom)
+      expect(result).toBeNull()
+    })
+  })
+
+  describe('buildBatchCancellation', () => {
+    const mockOrders: OrderCancellationParams[] = [
+      { encodedOrder: '0xencodedorder1', routing: TradingApi.Routing.DUTCH_V2, chainId, orderHash: '0xhash1' },
+      { encodedOrder: '0xencodedorder2', routing: TradingApi.Routing.DUTCH_V3, chainId, orderHash: '0xhash2' },
+    ]
+
+    it('should return null for empty orders array', async () => {
+      const result = await buildBatchCancellation([], mockFrom)
+      expect(result).toBeNull()
+    })
+
+    it('should use buildSingleCancellation for single order', async () => {
+      const singleOrder = [mockOrders[0]] as OrderCancellationParams[]
+
+      const result = await buildBatchCancellation(singleOrder, mockFrom)
+
+      expect(result).toEqual({
+        to: '0xpermit2address',
+        data: '0xcanceldata',
+        value: '0x0',
+        from: mockFrom,
+        chainId,
+      })
+
+      expect(getCancelMultipleParams).not.toHaveBeenCalled()
+      expect(getCancelSingleParams).toHaveBeenCalledWith(mockNonce)
+    })
+
+    it('should build batch cancellation for multiple orders', async () => {
+      const result = await buildBatchCancellation(mockOrders, mockFrom)
+
+      expect(result).toEqual({
+        to: '0xpermit2address',
+        data: '0xcanceldata',
+        value: '0x0',
+        from: mockFrom,
+        chainId,
+      })
+
+      expect(createPermit2Contract).toHaveBeenCalledTimes(1)
+      expect(getCancelMultipleParams).toHaveBeenCalledWith([mockNonce, mockNonce])
+      expect(mockPermit2.populateTransaction.invalidateUnorderedNonces).toHaveBeenCalledWith('0x789', '0xabc')
+    })
+
+    it('should handle multiple word/mask pairs', async () => {
+      const getCancelMultipleParamsMock = getCancelMultipleParams as Mock
+      getCancelMultipleParamsMock.mockReturnValue([
+        { word: '0x111', mask: '0x222' },
+        { word: '0x333', mask: '0x444' },
+      ])
+
+      const result = await buildBatchCancellation(mockOrders, mockFrom)
+
+      expect(Array.isArray(result)).toBe(true)
+      expect(result).toHaveLength(2)
+      expect(mockPermit2.populateTransaction.invalidateUnorderedNonces).toHaveBeenCalledTimes(2)
+      expect(mockPermit2.populateTransaction.invalidateUnorderedNonces).toHaveBeenCalledWith('0x111', '0x222')
+      expect(mockPermit2.populateTransaction.invalidateUnorderedNonces).toHaveBeenCalledWith('0x333', '0x444')
+    })
+
+    it('should filter out invalid orders', async () => {
+      const cosignedV3Parse = CosignedV3DutchOrder.parse as Mock
+      cosignedV3Parse.mockImplementationOnce(() => {
+        throw new Error('Parse error')
+      })
+
+      const result = await buildBatchCancellation(mockOrders, mockFrom)
+
+      expect(result).not.toBeNull()
+      expect(getCancelMultipleParams).toHaveBeenCalledWith([mockNonce]) // Only one valid nonce
+    })
+
+    it('should return null if all orders are invalid', async () => {
+      const cosignedV2Parse = CosignedV2DutchOrder.parse as Mock
+      const cosignedV3Parse = CosignedV3DutchOrder.parse as Mock
+      cosignedV2Parse.mockImplementation(() => {
+        throw new Error('Parse error')
+      })
+      cosignedV3Parse.mockImplementation(() => {
+        throw new Error('Parse error')
+      })
+
+      const result = await buildBatchCancellation(mockOrders, mockFrom)
+      expect(result).toBeNull()
+    })
+
+    it('should return null if orders are from different chains', async () => {
+      const mixedChainOrders: OrderCancellationParams[] = [
+        { ...mockOrders[0]!, chainId: UniverseChainId.Mainnet },
+        { ...mockOrders[1]!, chainId: UniverseChainId.ArbitrumOne },
+      ]
+
+      const result = await buildBatchCancellation(mixedChainOrders, mockFrom)
+      expect(result).toBeNull()
+    })
+
+    it('should handle empty orders array gracefully', async () => {
+      const ordersWithEmpty: OrderCancellationParams[] = []
+
+      const result = await buildBatchCancellation(ordersWithEmpty, mockFrom)
+      expect(result).toBeNull()
+    })
+
+    it('should handle orders array with undefined elements', async () => {
+      // This tests the case where orders[0] could be undefined
+      const result = await buildBatchCancellation([mockOrders[0]!], mockFrom)
+
+      expect(result).not.toBeNull()
+      expect(getCancelSingleParams).toHaveBeenCalledWith(mockNonce)
+    })
+
+    it('should return null when getCancelMultipleParams returns empty array', async () => {
+      const getCancelMultipleParamsMock = getCancelMultipleParams as Mock
+      getCancelMultipleParamsMock.mockReturnValue([])
+
+      const result = await buildBatchCancellation(mockOrders, mockFrom)
+      expect(result).toBeNull()
+    })
+
+    it('should return null when getCancelMultipleParams first param is undefined', async () => {
+      const getCancelMultipleParamsMock = getCancelMultipleParams as Mock
+      getCancelMultipleParamsMock.mockReturnValue([undefined])
+
+      const result = await buildBatchCancellation(mockOrders, mockFrom)
+      expect(result).toBeNull()
+    })
+  })
+
+  describe('error handling', () => {
+    it('should handle permit2 contract creation failure', async () => {
+      const mockCreatePermit2Contract = createPermit2Contract as Mock
+      mockCreatePermit2Contract.mockImplementation(() => {
+        throw new Error('Contract creation failed')
+      })
+
+      const mockOrder: OrderCancellationParams = {
+        encodedOrder: '0xencodedorder',
+        routing: TradingApi.Routing.DUTCH_V2,
+        chainId,
+        orderHash: '0xhash',
+      }
+
+      const result = await buildSingleCancellation(mockOrder, mockFrom)
+      expect(result).toBeNull()
+    })
+
+    it('should handle populateTransaction failure', async () => {
+      mockPermit2.populateTransaction.invalidateUnorderedNonces.mockRejectedValue(new Error('Transaction failed'))
+
+      const mockOrder: OrderCancellationParams = {
+        encodedOrder: '0xencodedorder',
+        routing: TradingApi.Routing.DUTCH_V2,
+        chainId,
+        orderHash: '0xhash',
+      }
+
+      const result = await buildSingleCancellation(mockOrder, mockFrom)
+      expect(result).toBeNull()
+    })
+  })
+})

package/src/features/transactions/cancel/cancelOrderFactory.ts

@@ -0,0 +1,161 @@
+import { BigNumber } from '@ethersproject/bignumber'
+import {
+  CosignedPriorityOrder,
+  CosignedV2DutchOrder,
+  CosignedV3DutchOrder,
+  DutchOrder,
+  getCancelMultipleParams,
+  getCancelSingleParams,
+} from '@luxdex/sdk'
+import { TradingApi } from '@luxfi/api'
+import { providers } from 'ethers/lib/ethers'
+import { UniverseChainId } from '@luxexchange/lx/src/features/chains/types'
+import { createPermit2Contract } from '@luxexchange/lx/src/features/transactions/utils/permit2'
+import { logger } from '@luxfi/utilities/src/logger/logger'
+
+const ROUTING_TO_ORDER_CLASS = {
+  [TradingApi.Routing.DUTCH_V2]: CosignedV2DutchOrder,
+  [TradingApi.Routing.DUTCH_V3]: CosignedV3DutchOrder,
+  [TradingApi.Routing.PRIORITY]: CosignedPriorityOrder,
+  [TradingApi.Routing.DUTCH_LIMIT]: DutchOrder,
+} as const
+
+export interface OrderCancellationParams {
+  encodedOrder: string
+  routing: TradingApi.Routing
+  chainId: UniverseChainId
+  orderHash?: string
+}
+
+/**
+ * Builds a transaction to cancel a single DEX order
+ */
+export async function buildSingleCancellation(
+  order: OrderCancellationParams,
+  from: string,
+): Promise<providers.TransactionRequest | null> {
+  try {
+    const nonce = extractNonceFromOrder(order)
+    if (!nonce) {
+      return null
+    }
+
+    const permit2 = createPermit2Contract()
+    const cancelParams = getCancelSingleParams(nonce)
+    const tx = await permit2.populateTransaction.invalidateUnorderedNonces(cancelParams.word, cancelParams.mask)
+
+    return {
+      ...tx,
+      from,
+      chainId: order.chainId,
+    }
+  } catch (error) {
+    logger.debug('cancelOrderFactory', 'buildSingleCancellation', 'Failed to build single cancellation', {
+      error,
+      orderHash: order.orderHash,
+    })
+    return null
+  }
+}
+
+/**
+ * Builds transactions to cancel multiple DEX orders
+ * Returns array of transactions when multiple word/mask pairs are needed
+ */
+export async function buildBatchCancellation(
+  orders: OrderCancellationParams[],
+  from: string,
+): Promise<providers.TransactionRequest[] | providers.TransactionRequest | null> {
+  if (orders.length === 0) {
+    return null
+  }
+
+  try {
+    // For a single order, use the more efficient single cancellation
+    if (orders.length === 1) {
+      const order = orders[0]
+      if (!order) {
+        return null
+      }
+      return buildSingleCancellation(order, from)
+    }
+
+    // All orders must be from the same chain for batch cancellation
+    const chainId = orders[0]?.chainId
+    if (!chainId || !orders.every((order) => order.chainId === chainId)) {
+      logger.debug('cancelOrderFactory', 'buildBatchCancellation', 'All orders must be from the same chain')
+      return null
+    }
+
+    // Extract nonces from all orders
+    const nonces = orders
+      .map((order) => extractNonceFromOrder(order))
+      .filter((nonce): nonce is BigNumber => nonce !== null)
+
+    if (nonces.length === 0) {
+      logger.debug('cancelOrderFactory', 'buildBatchCancellation', 'No valid nonces found in orders')
+      return null
+    }
+
+    // Get cancellation parameters for multiple nonces
+    const cancelParams = getCancelMultipleParams(nonces)
+
+    if (cancelParams.length === 0) {
+      return null
+    }
+
+    const permit2 = createPermit2Contract()
+
+    // Build transaction for each word/mask pair
+    if (cancelParams.length === 1) {
+      const param = cancelParams[0]
+      if (!param) {
+        return null
+      }
+      const tx = await permit2.populateTransaction.invalidateUnorderedNonces(param.word, param.mask)
+      return {
+        ...tx,
+        from,
+        chainId,
+      }
+    }
+
+    // Multiple word/mask pairs require multiple transactions
+    const transactions = await Promise.all(
+      cancelParams.map(async (param) => {
+        const tx = await permit2.populateTransaction.invalidateUnorderedNonces(param.word, param.mask)
+        return {
+          ...tx,
+          from,
+          chainId,
+        }
+      }),
+    )
+
+    return transactions
+  } catch (error) {
+    logger.debug('cancelOrderFactory', 'buildBatchCancellation', 'Failed to build batch cancellation', {
+      error,
+      orderCount: orders.length,
+    })
+    return null
+  }
+}
+
+/**
+ * Extracts the nonce from an encoded order based on its routing type
+ */
+function extractNonceFromOrder(order: OrderCancellationParams): BigNumber | null {
+  try {
+    const orderClass = ROUTING_TO_ORDER_CLASS[order.routing as keyof typeof ROUTING_TO_ORDER_CLASS]
+    const parsedOrder = orderClass.parse(order.encodedOrder, order.chainId)
+    return parsedOrder.info.nonce
+  } catch (error) {
+    logger.debug('cancelOrderFactory', 'extractNonceFromOrder', 'Failed to parse order', {
+      error,
+      orderHash: order.orderHash,
+      routing: order.routing,
+    })
+    return null
+  }
+}

package/src/features/transactions/cancel/getCancelOrderTxRequest.ts

@@ -0,0 +1,39 @@
+import { TradingApi } from '@luxexchange/api'
+import { providers } from 'ethers/lib/ethers'
+import { buildSingleCancellation } from '@luxexchange/lx/src/features/transactions/cancel/cancelOrderFactory'
+import { getOrders } from '@luxexchange/lx/src/features/transactions/swap/orders'
+import { DEXOrderDetails } from '@luxexchange/lx/src/features/transactions/types/transactionDetails'
+
+export async function getCancelOrderTxRequest(tx: DEXOrderDetails): Promise<providers.TransactionRequest | null> {
+  const { orderHash, chainId, from, routing, encodedOrder: localEncodedOrder } = tx
+
+  if (!orderHash) {
+    return null
+  }
+
+  // Always fetch the latest order status from the API to verify the order is still cancellable
+  const apiOrder = (await getOrders([orderHash])).orders[0]
+  const currentOrderStatus = apiOrder?.orderStatus
+
+  // If the order is already filled, expired, or cancelled, no point in submitting a cancel tx
+  if (currentOrderStatus && currentOrderStatus !== TradingApi.OrderStatus.OPEN) {
+    return null
+  }
+
+  // Use locally stored encodedOrder if available, otherwise use the one from the API response
+  const encodedOrder = localEncodedOrder ?? apiOrder?.encodedOrder
+
+  if (!encodedOrder) {
+    return null
+  }
+
+  return buildSingleCancellation(
+    {
+      encodedOrder,
+      routing,
+      chainId,
+      orderHash,
+    },
+    from,
+  )
+}

package/src/features/transactions/cancel/validation.test.ts

@@ -0,0 +1,99 @@
+import { UniverseChainId } from '@luxexchange/lx/src/features/chains/types'
+import { validateOrdersForCancellation } from '@luxexchange/lx/src/features/transactions/cancel/validation'
+import { DEXOrderDetails } from '@luxexchange/lx/src/features/transactions/types/transactionDetails'
+import { dexOrderDetails } from '@luxexchange/lx/src/test/fixtures'
+
+describe('validateOrdersForCancellation', () => {
+  const createMockOrder = (overrides?: Partial<DEXOrderDetails>): DEXOrderDetails =>
+    dexOrderDetails(overrides ?? {}) as DEXOrderDetails
+
+  describe('empty orders', () => {
+    it('should return error for empty array', () => {
+      const result = validateOrdersForCancellation([])
+      expect(result.valid).toBe(false)
+      expect(result.error).toBe('Invalid orders array')
+    })
+  })
+
+  describe('chain validation', () => {
+    it('should return valid for single order', () => {
+      const orders = [createMockOrder()]
+      const result = validateOrdersForCancellation(orders)
+      expect(result.valid).toBe(true)
+      expect(result.chainId).toBe(UniverseChainId.Mainnet)
+    })
+
+    it('should return valid for multiple orders on same chain', () => {
+      const orders = [
+        createMockOrder({ id: 'order1' }),
+        createMockOrder({ id: 'order2' }),
+        createMockOrder({ id: 'order3' }),
+      ]
+      const result = validateOrdersForCancellation(orders)
+      expect(result.valid).toBe(true)
+      expect(result.chainId).toBe(UniverseChainId.Mainnet)
+    })
+
+    it('should return error for orders on different chains', () => {
+      const orders = [
+        createMockOrder({ chainId: UniverseChainId.Mainnet }),
+        createMockOrder({ chainId: UniverseChainId.ArbitrumOne }),
+        createMockOrder({ chainId: UniverseChainId.Optimism }),
+      ]
+      const result = validateOrdersForCancellation(orders)
+      expect(result.valid).toBe(false)
+      expect(result.error).toContain('Cannot cancel orders from different chains')
+      expect(result.error).toContain('1, 42161, 10')
+    })
+
+    it('should return error for mixed chains even with mostly same chain', () => {
+      const orders = [
+        createMockOrder({ chainId: UniverseChainId.Mainnet }),
+        createMockOrder({ chainId: UniverseChainId.Mainnet }),
+        createMockOrder({ chainId: UniverseChainId.ArbitrumOne }),
+      ]
+      const result = validateOrdersForCancellation(orders)
+      expect(result.valid).toBe(false)
+      expect(result.error).toContain('Cannot cancel orders from different chains')
+    })
+  })
+
+  describe('encoded data validation', () => {
+    it('should return valid when all orders have encoded data', () => {
+      const orders = [createMockOrder({ encodedOrder: '0xencoded1' }), createMockOrder({ encodedOrder: '0xencoded2' })]
+      const result = validateOrdersForCancellation(orders)
+      expect(result.valid).toBe(true)
+    })
+
+    it('should return valid when some orders have encoded data', () => {
+      const orders = [createMockOrder({ encodedOrder: '0xencoded1' }), createMockOrder({ encodedOrder: undefined })]
+      const result = validateOrdersForCancellation(orders)
+      expect(result.valid).toBe(true)
+    })
+  })
+
+  describe('complex scenarios', () => {
+    it('should validate successfully for valid batch', () => {
+      const orders = [
+        createMockOrder({
+          id: 'order1',
+          chainId: UniverseChainId.Polygon,
+          encodedOrder: '0xencoded1',
+        }),
+        createMockOrder({
+          id: 'order2',
+          chainId: UniverseChainId.Polygon,
+          encodedOrder: '0xencoded2',
+        }),
+        createMockOrder({
+          id: 'order3',
+          chainId: UniverseChainId.Polygon,
+          encodedOrder: undefined, // Some orders without encoded data is ok
+        }),
+      ]
+      const result = validateOrdersForCancellation(orders)
+      expect(result.valid).toBe(true)
+      expect(result.chainId).toBe(UniverseChainId.Polygon)
+    })
+  })
+})

package/src/features/transactions/cancel/validation.ts

@@ -0,0 +1,57 @@
+import { UniverseChainId } from '@luxexchange/lx/src/features/chains/types'
+import { DEXOrderDetails } from '@luxexchange/lx/src/features/transactions/types/transactionDetails'
+import { hasEncodedOrder } from '@luxexchange/lx/src/features/transactions/utils/dex.utils'
+
+/**
+ * Result of order validation
+ */
+export type ValidationResult =
+  | {
+      valid: true
+      chainId: UniverseChainId
+      error?: never
+    }
+  | {
+      valid: false
+      chainId?: never
+      error: string
+    }
+
+/**
+ * Type guard to check if an order has all required data for cancellation
+ */
+export function hasValidCancellationData(order: DEXOrderDetails): order is DEXOrderDetails & {
+  orderHash: string
+  encodedOrder: string
+} {
+  return hasEncodedOrder(order) && order.orderHash !== undefined
+}
+
+/**
+ * Validates that orders can be cancelled together
+ * This is the single source of truth for cancellation validation
+ *
+ * @param orders - Orders to validate for batch cancellation
+ * @returns Validation result with chainId if valid, or error message if invalid
+ */
+export function validateOrdersForCancellation(orders: DEXOrderDetails[]): ValidationResult {
+  // Get the chain ID from the first order
+  const firstOrder = orders[0]
+  if (!firstOrder) {
+    return { valid: false, error: 'Invalid orders array' }
+  }
+
+  const firstChainId = firstOrder.chainId
+
+  // Check all orders are on the same chain
+  const allSameChain = orders.every((order) => order.chainId === firstChainId)
+  if (!allSameChain) {
+    const uniqueChains = [...new Set(orders.map((o) => o.chainId))]
+    return {
+      valid: false,
+      error: `Cannot cancel orders from different chains (found: ${uniqueChains.join(', ')})`,
+    }
+  }
+
+  return { valid: true, chainId: firstChainId }
+}