feat: remove dependency on indicativePrice when getting price for limit order

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

@@ -37,14 +37,16 @@ export interface DealTicketFeeDetailsProps {
   assetSymbol: string;
   order: OrderSubmissionBody['orderSubmission'];
   market: Market;
+  isMarketInAuction?: boolean;
 }
 
 export const DealTicketFeeDetails = ({
   assetSymbol,
   order,
   market,
+  isMarketInAuction,
 }: DealTicketFeeDetailsProps) => {
-  const feeEstimate = useEstimateFees(order);
+  const feeEstimate = useEstimateFees(order, isMarketInAuction);
   const { settlementAsset: asset } =
     market.tradableInstrument.instrument.product;
   const { decimals: assetDecimals, quantum } = asset;
@@ -64,7 +66,7 @@ export const DealTicketFeeDetails = ({
         <>
           <span>
             {t(
-              `An estimate of the most you would be expected to pay in fees, in the market's settlement asset ${assetSymbol}.`
+              `An estimate of the most you would be expected to pay in fees, in the market's settlement asset ${assetSymbol}. Fees estimated are "taker" fees and will only be payable if the order trades aggressively. Rebate equal to the maker portion will be paid to the trader if the order trades passively.`
             )}
           </span>
           <FeesBreakdown

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

@@ -36,7 +36,7 @@ import {
   formatValue,
 } from '@vegaprotocol/utils';
 import { activeOrdersProvider } from '@vegaprotocol/orders';
-import { getDerivedPrice } from '@vegaprotocol/markets';
+import { getDerivedPrice, isMarketInAuction } from '@vegaprotocol/markets';
 import {
   validateExpiration,
   validateMarketState,
@@ -182,6 +182,7 @@ export const DealTicket = ({
   const iceberg = watch('iceberg');
   const peakSize = watch('peakSize');
   const expiresAt = watch('expiresAt');
+  const postOnly = watch('postOnly');
 
   useEffect(() => {
     const size = storedFormValues?.[dealTicketType]?.size;
@@ -211,6 +212,7 @@ export const DealTicket = ({
       size: rawSize,
       timeInForce,
       type,
+      postOnly,
     },
     market.id,
     market.decimalPlaces,
@@ -219,8 +221,7 @@ export const DealTicket = ({
 
   const price =
     normalizedOrder &&
-    marketPrice &&
-    getDerivedPrice(normalizedOrder, marketPrice);
+    getDerivedPrice(normalizedOrder, marketPrice ?? undefined);
 
   const notionalSize = getNotionalSize(
     price,
@@ -474,6 +475,7 @@ export const DealTicket = ({
           }
           assetSymbol={assetSymbol}
           market={market}
+          isMarketInAuction={isMarketInAuction(marketData.marketTradingMode)}
         />
       </div>
       <Controller

libs/deal-ticket/src/hooks/use-estimate-fees.spec.tsx

@@ -0,0 +1,78 @@
+import { renderHook } from '@testing-library/react';
+import { useEstimateFees } from './use-estimate-fees';
+import { Side, OrderTimeInForce, OrderType } from '@vegaprotocol/types';
+
+import type { EstimateFeesQuery } from './__generated__/EstimateOrder';
+
+const data: EstimateFeesQuery = {
+  estimateFees: {
+    totalFeeAmount: '12',
+    fees: {
+      infrastructureFee: '2',
+      liquidityFee: '4',
+      makerFee: '6',
+    },
+  },
+};
+
+const mockUseEstimateFeesQuery = jest.fn((...args) => ({
+  data,
+}));
+
+jest.mock('./__generated__/EstimateOrder', () => ({
+  ...jest.requireActual('@vegaprotocol/data-provider'),
+  useEstimateFeesQuery: jest.fn((...args) => mockUseEstimateFeesQuery(...args)),
+}));
+
+jest.mock('@vegaprotocol/wallet', () => ({
+  useVegaWallet: () => ({ pubKey: 'pubKey' }),
+}));
+
+describe('useEstimateFees', () => {
+  it('returns 0 as estimated values if order is postOnly', () => {
+    const { result } = renderHook(() =>
+      useEstimateFees({
+        marketId: 'marketId',
+        side: Side.SIDE_BUY,
+        size: '1',
+        price: '1',
+        timeInForce: OrderTimeInForce.TIME_IN_FORCE_FOK,
+        type: OrderType.TYPE_LIMIT,
+        postOnly: true,
+      })
+    );
+    expect(result.current).toEqual({
+      totalFeeAmount: '0',
+      fees: {
+        infrastructureFee: '0',
+        liquidityFee: '0',
+        makerFee: '0',
+      },
+    });
+    expect(mockUseEstimateFeesQuery.mock.lastCall?.[0].skip).toBeTruthy();
+  });
+
+  it('divide values by 2 if market is in auction', () => {
+    const { result } = renderHook(() =>
+      useEstimateFees(
+        {
+          marketId: 'marketId',
+          side: Side.SIDE_BUY,
+          size: '1',
+          price: '1',
+          timeInForce: OrderTimeInForce.TIME_IN_FORCE_FOK,
+          type: OrderType.TYPE_LIMIT,
+        },
+        true
+      )
+    );
+    expect(result.current).toEqual({
+      totalFeeAmount: '6',
+      fees: {
+        infrastructureFee: '1',
+        liquidityFee: '2',
+        makerFee: '3',
+      },
+    });
+  });
+});

libs/deal-ticket/src/hooks/use-estimate-fees.tsx

@@ -1,13 +1,16 @@
 import { useVegaWallet } from '@vegaprotocol/wallet';
 import type { OrderSubmissionBody } from '@vegaprotocol/wallet';
 
+import type { EstimateFeesQuery } from './__generated__/EstimateOrder';
 import { useEstimateFeesQuery } from './__generated__/EstimateOrder';
 
-export const useEstimateFees = (
-  order?: OrderSubmissionBody['orderSubmission']
-) => {
-  const { pubKey } = useVegaWallet();
+const divideByTwo = (n: string) => (BigInt(n) / BigInt(2)).toString();
 
+export const useEstimateFees = (
+  order?: OrderSubmissionBody['orderSubmission'],
+  isMarketInAuction?: boolean
+): EstimateFeesQuery['estimateFees'] | undefined => {
+  const { pubKey } = useVegaWallet();
   const { data } = useEstimateFeesQuery({
     variables: order && {
       marketId: order.marketId,
@@ -19,7 +22,28 @@ export const useEstimateFees = (
       type: order.type,
     },
     fetchPolicy: 'no-cache',
-    skip: !pubKey || !order?.size || !order?.price,
+    skip: !pubKey || !order?.size || !order?.price || order.postOnly,
   });
-  return data?.estimateFees;
+  if (order?.postOnly) {
+    return {
+      totalFeeAmount: '0',
+      fees: {
+        infrastructureFee: '0',
+        liquidityFee: '0',
+        makerFee: '0',
+      },
+    };
+  }
+  return isMarketInAuction && data?.estimateFees
+    ? {
+        totalFeeAmount: divideByTwo(data.estimateFees.totalFeeAmount),
+        fees: {
+          infrastructureFee: divideByTwo(
+            data.estimateFees.fees.infrastructureFee
+          ),
+          liquidityFee: divideByTwo(data.estimateFees.fees.liquidityFee),
+          makerFee: divideByTwo(data.estimateFees.fees.makerFee),
+        },
+      }
+    : data?.estimateFees;
 };

libs/markets/src/lib/components/fees-breakdown/fees-breakdown.tsx

@@ -60,6 +60,7 @@ export const FeesBreakdown = ({
     .plus(fees.infrastructureFee)
     .plus(fees.liquidityFee)
     .toString();
+  if (totalFees === '0') return null;
   const formatValue = (value: string | number | null | undefined): string => {
     return value && !isNaN(Number(value))
       ? addDecimalsFormatNumber(value, decimals)

libs/markets/src/lib/get-price.ts

@@ -33,7 +33,7 @@ export const getDerivedPrice = (
     type: Schema.OrderType;
     price?: string | undefined;
   },
-  marketPrice: string
+  marketPrice?: string
 ) => {
   // If order type is market we should use either the mark price
   // or the uncrossing price. If order type is limit use the price