chore: add helper for persistant order check

libs/deal-ticket/src/components/deal-ticket/deal-ticket.tsx

@@ -71,6 +71,7 @@ import type { OrderFormValues } from '../../hooks/use-form-values';
 import { useDealTicketFormValues } from '../../hooks/use-form-values';
 import { DealTicketSizeIceberg } from './deal-ticket-size-iceberg';
 import noop from 'lodash/noop';
+import { isNonPersistentOrder } from '../../utils/time-in-force-persistance';
 
 export const REDUCE_ONLY_TOOLTIP =
   '"Reduce only" will ensure that this order will not increase the size of an open position. When the order is matched, it will only trade enough volume to bring your open volume towards 0 but never change the direction of your position. If applied to a limit order that is not instantly filled, the order will be stopped.';
@@ -307,14 +308,10 @@ export const DealTicket = ({
     pubKey,
   ]);
 
-  const iocOrFok = [
-    Schema.OrderTimeInForce.TIME_IN_FORCE_IOC,
-    Schema.OrderTimeInForce.TIME_IN_FORCE_FOK,
-  ].includes(timeInForce);
-
-  const disablePostOnlyCheckbox = iocOrFok;
-  const disableReduceOnlyCheckbox = !iocOrFok;
-  const disableIcebergCheckbox = iocOrFok;
+  const nonPersistentOrder = isNonPersistentOrder(timeInForce);
+  const disablePostOnlyCheckbox = nonPersistentOrder;
+  const disableReduceOnlyCheckbox = !nonPersistentOrder;
+  const disableIcebergCheckbox = nonPersistentOrder;
 
   const onSubmit = useCallback(
     (formValues: OrderFormValues) => {
@@ -470,13 +467,7 @@ export const DealTicket = ({
             value={field.value}
             orderType={type}
             onSelect={(value) => {
-              if (
-                iceberg &&
-                [
-                  Schema.OrderTimeInForce.TIME_IN_FORCE_IOC,
-                  Schema.OrderTimeInForce.TIME_IN_FORCE_FOK,
-                ].includes(value)
-              ) {
+              if (iceberg && isNonPersistentOrder(value)) {
                 setValue('iceberg', false);
               }
               field.onChange(value);

libs/deal-ticket/src/utils/map-form-values-to-submission.ts

@@ -9,6 +9,7 @@ import type {
 } from '../hooks/use-form-values';
 import * as Schema from '@vegaprotocol/types';
 import { removeDecimal, toNanoSeconds } from '@vegaprotocol/utils';
+import { isPersistentOrder } from './time-in-force-persistance';
 
 export const mapFormValuesToOrderSubmission = (
   order: OrderFormValues,
@@ -42,10 +43,7 @@ export const mapFormValuesToOrderSubmission = (
       : order.reduceOnly,
   icebergOpts:
     order.type === Schema.OrderType.TYPE_LIMIT &&
-    ![
-      Schema.OrderTimeInForce.TIME_IN_FORCE_FOK,
-      Schema.OrderTimeInForce.TIME_IN_FORCE_IOC,
-    ].includes(order.timeInForce) &&
+    isPersistentOrder(order.timeInForce) &&
     order.iceberg &&
     order.peakSize &&
     order.minimumVisibleSize

libs/deal-ticket/src/utils/time-in-force-persistance.spec.ts

@@ -0,0 +1,23 @@
+import { OrderTimeInForce } from '@vegaprotocol/types';
+import {
+  isNonPersistentOrder,
+  isPersistentOrder,
+} from './time-in-force-persistance';
+
+it('isNonPeristentOrder', () => {
+  expect(isNonPersistentOrder(OrderTimeInForce.TIME_IN_FORCE_FOK)).toBe(true);
+  expect(isNonPersistentOrder(OrderTimeInForce.TIME_IN_FORCE_IOC)).toBe(true);
+  expect(isNonPersistentOrder(OrderTimeInForce.TIME_IN_FORCE_GTC)).toBe(false);
+  expect(isNonPersistentOrder(OrderTimeInForce.TIME_IN_FORCE_GTT)).toBe(false);
+  expect(isNonPersistentOrder(OrderTimeInForce.TIME_IN_FORCE_GFA)).toBe(false);
+  expect(isNonPersistentOrder(OrderTimeInForce.TIME_IN_FORCE_GFN)).toBe(false);
+});
+
+it('isPeristentOrder', () => {
+  expect(isPersistentOrder(OrderTimeInForce.TIME_IN_FORCE_FOK)).toBe(false);
+  expect(isPersistentOrder(OrderTimeInForce.TIME_IN_FORCE_IOC)).toBe(false);
+  expect(isPersistentOrder(OrderTimeInForce.TIME_IN_FORCE_GTC)).toBe(true);
+  expect(isPersistentOrder(OrderTimeInForce.TIME_IN_FORCE_GTT)).toBe(true);
+  expect(isPersistentOrder(OrderTimeInForce.TIME_IN_FORCE_GFA)).toBe(true);
+  expect(isPersistentOrder(OrderTimeInForce.TIME_IN_FORCE_GFN)).toBe(true);
+});

libs/deal-ticket/src/utils/time-in-force-persistance.ts

@@ -0,0 +1,12 @@
+import { OrderTimeInForce } from '@vegaprotocol/types';
+
+export const isNonPersistentOrder = (timeInForce: OrderTimeInForce) => {
+  return [
+    OrderTimeInForce.TIME_IN_FORCE_FOK,
+    OrderTimeInForce.TIME_IN_FORCE_IOC,
+  ].includes(timeInForce);
+};
+
+export const isPersistentOrder = (timeInForce: OrderTimeInForce) => {
+  return !isNonPersistentOrder(timeInForce);
+};