fix(perps): reduce max order amount by 0.5% buffer to avoid insufficient margin rejections (MetaMask#27417)

michalconsensys · web-flow · commit 6fa43afd3c45 · 2026-03-25T09:46:27.000Z
## **Description** When users place a long/short Perps order with the amount slider at 100% (or tap "Max"), the app was sending the full theoretical maximum (available balance × leverage). The HyperLiquid API sometimes rejects these with "Order 0: Insufficient margin to place order" due to fees, rounding, and exchange-side margin checks. **Solution:** Introduce a 0.5% margin buffer on the maximum order amount so that "100%" uses 99.5% of the theoretical max. This is applied in a single place (`getMaxAllowedAmount`), and the order form uses this buffered value for the slider max, Max button, and 100% quick button so all paths stay consistent. The buffer is configurable via `MAX_ORDER_MARGIN_BUFFER` in perps config for future tuning or smarter logic (e.g. fee-based). **Changes:** - **perpsConfig**: Added `MAX_ORDER_MARGIN_BUFFER = 0.005` (0.5%). - **getMaxAllowedAmount**: After existing rounding logic, multiply max by `(1 - MAX_ORDER_MARGIN_BUFFER)` and return `floor(bufferedMax)`. - **usePerpsOrderForm**: `handleMaxAmount` and `handlePercentageAmount(1)` now set amount to `maxPossibleAmount` (the buffered max) instead of computing `balance × leverage` directly. - **Tests**: Updated expectations for low-balance scenarios (e.g. $2 @ 3x → max 5 instead of 6); added test that max is below theoretical after buffer. ## **Changelog** CHANGELOG entry: Fixed Perps orders at 100% margin sometimes failing with "Insufficient margin" by applying a small buffer to the maximum order amount. ## **Related issues** Fixes: https://consensyssoftware.atlassian.net/browse/TAT-2502 ## **Manual testing steps** ```gherkin Feature: Perps order placement at maximum margin Scenario: user places order at 100% (slider or Max) without insufficient margin error Given user is on Perps order view with available balance and an asset selected When user sets amount to 100% via the slider or taps the Max / 100% button Then the amount field shows the buffered max (slightly below theoretical max) And placing the order does not result in "Insufficient margin" rejection from the exchange ``` ## **Screenshots/Recordings**  ### **Before** N/A (behavioral fix; no UI change) ### **After** N/A ## **Pre-merge author checklist** - [x] I've followed [MetaMask Contributor Docs](https://github.com/MetaMask/contributor-docs) and [MetaMask Mobile Coding Standards](https://github.com/MetaMask/metamask-mobile/blob/main/.github/guidelines/CODING_GUIDELINES.md). - [x] I've completed the PR template to the best of my ability - [x] I've included tests if applicable - [x] I've documented my code using [JSDoc](https://jsdoc.app/) format if applicable - [x] I've applied the right labels on the PR (see [labeling guidelines](https://github.com/MetaMask/metamask-mobile/blob/main/.github/guidelines/LABELING_GUIDELINES.md)). Not required for external contributors. ## **Pre-merge reviewer checklist** - [ ] I've manually tested the PR (e.g. pull and build branch, run the app, test code being changed). - [ ] I confirm that this PR addresses all acceptance criteria described in the ticket it closes and includes the necessary testing evidence such as recordings and or screenshots.  --- > [!NOTE] > **Medium Risk** > Adjusts core order-sizing calculations for max/percentage selections, which can affect how much users trade and may surface edge cases around rounding and balance updates. Changes are localized and covered by updated/additional tests. > > **Overview** > Reduces Perps *maximum order amount* by applying a configurable **0.5% margin buffer** so “Max”/100% selections are less likely to be rejected as *Insufficient margin*. > > This adds `MAX_ORDER_MARGIN_BUFFER` and applies it in `getMaxAllowedAmount`, then updates `usePerpsOrderForm` handlers to clamp percentage-based amounts and set Max to `maxPossibleAmount` (the buffered max). Tests are updated to reflect new buffered expectations and add coverage for near-100% clamping and buffered-max behavior. > > <sup>Written by [Cursor Bugbot](https://cursor.com/dashboard?tab=bugbot) for commit 03168c3. This will update automatically on new commits. Configure [here](https://cursor.com/dashboard?tab=bugbot).</sup>
diff --git a/app/components/UI/Perps/hooks/usePerpsOrderForm.test.ts b/app/components/UI/Perps/hooks/usePerpsOrderForm.test.ts
@@ -435,9 +435,9 @@ describe('usePerpsOrderForm', () => {
       });
 
       // Assert
-      // With $2 balance and 3x leverage = $6 max amount, which is less than $10 default
-      // Should use the max possible amount ($6) instead of the default ($10)
-      expect(result.current.orderForm.amount).toBe('6');
+      // With $2 balance and 3x leverage, max is floor(6 * (1 - 0.5% buffer)) = 5 (less than $10 default)
+      // Should use the max possible amount (5) instead of the default ($10)
+      expect(result.current.orderForm.amount).toBe('5');
     });
 
     it('should use default amount when available balance times leverage is greater than default amount', () => {
@@ -468,14 +468,14 @@ describe('usePerpsOrderForm', () => {
 
   describe('useMemo and useEffect behavior', () => {
     it('should not overwrite user input when dependencies change', async () => {
-      // Arrange - Start with balance high enough that max >= 999 (e.g. 334 * 3x = 1002)
+      // Arrange - Start with balance high enough that max >= 999 after 0.5% buffer (e.g. 335 * 3x → floor(1005*0.995) = 999)
       const mockAccount = {
         account: {
-          availableBalance: '334',
+          availableBalance: '335',
           marginUsed: '0',
           unrealizedPnl: '0',
           returnOnEquity: '0',
-          totalBalance: '334',
+          totalBalance: '335',
         },
         isInitialLoading: false,
       };
@@ -490,7 +490,7 @@ describe('usePerpsOrderForm', () => {
         TRADING_DEFAULTS.amount.mainnet.toString(),
       );
 
-      // Act - User changes the amount (within current max)
+      // Act - User changes the amount (within current max; 335*3*0.995 >= 999)
       act(() => {
         result.current.setAmount('999');
       });
@@ -515,7 +515,7 @@ describe('usePerpsOrderForm', () => {
       // Test 1: Low balance scenario
       mockUsePerpsLiveAccount.mockReturnValue({
         account: {
-          availableBalance: '2', // $2 balance = $6 max with 3x leverage (less than $10 default)
+          availableBalance: '2', // $2 balance, 3x leverage: max = floor(6 * 0.995) = 5 (less than $10 default)
           marginUsed: '0',
           unrealizedPnl: '0',
           returnOnEquity: '0',
@@ -528,7 +528,7 @@ describe('usePerpsOrderForm', () => {
         wrapper: createWrapper(),
       });
 
-      expect(result1.current.orderForm.amount).toBe('6'); // Should use maxPossibleAmount
+      expect(result1.current.orderForm.amount).toBe('5'); // Should use maxPossibleAmount (with margin buffer)
 
       // Test 2: High balance scenario
       mockUsePerpsLiveAccount.mockReturnValue({
@@ -690,7 +690,8 @@ describe('usePerpsOrderForm', () => {
         result.current.handleMaxAmount();
       });
 
-      expect(result.current.orderForm.amount).toBe('3000'); // 1000 * 3x leverage
+      // 1000 * 3x leverage with 0.5% margin buffer = floor(3000 * 0.995) = 2985
+      expect(result.current.orderForm.amount).toBe('2985');
     });
 
     it('should handle min amount for mainnet', () => {
@@ -722,6 +723,27 @@ describe('usePerpsOrderForm', () => {
       );
     });
 
+    it('should clamp near-100% amounts to maxPossibleAmount', () => {
+      const { result } = renderHook(() => usePerpsOrderForm(), {
+        wrapper: createWrapper(),
+      });
+
+      act(() => {
+        result.current.handlePercentageAmount(0.999);
+      });
+
+      const at999 = Number(result.current.orderForm.amount);
+
+      act(() => {
+        result.current.handlePercentageAmount(1);
+      });
+
+      const at100 = Number(result.current.orderForm.amount);
+
+      expect(at999).toBeLessThanOrEqual(at100);
+      expect(at100).toBe(result.current.maxPossibleAmount);
+    });
+
     it('should not update amount when balance is 0', () => {
       mockUsePerpsLiveAccount.mockReturnValue({
         account: {
diff --git a/app/components/UI/Perps/hooks/usePerpsOrderForm.ts b/app/components/UI/Perps/hooks/usePerpsOrderForm.ts
@@ -317,26 +317,28 @@ export function usePerpsOrderForm(
     setOrderForm((prev) => ({ ...prev, type }));
   };
 
-  // Handle percentage-based amount selection (respects custom token amount when set)
+  // Handle percentage-based amount selection (respects custom token amount when set).
+  // Clamp to maxPossibleAmount so near-100% values never exceed the buffered max.
   const handlePercentageAmount = useCallback(
     (percentage: number) => {
       if (balanceForMax === 0) return;
-      const newAmount = Math.floor(
-        balanceForMax * orderForm.leverage * percentage,
-      ).toString();
+      const raw = balanceForMax * orderForm.leverage * percentage;
+      const clamped = Math.min(raw, maxPossibleAmount);
+      const newAmount = Math.floor(clamped).toString();
       setOrderForm((prev) => ({ ...prev, amount: newAmount }));
     },
-    [balanceForMax, orderForm.leverage],
+    [balanceForMax, orderForm.leverage, maxPossibleAmount],
   );
 
-  // Handle max amount selection (respects custom token amount when set)
+  // Handle max amount selection (respects custom token amount when set).
+  // Uses maxPossibleAmount (includes margin buffer) to avoid "Insufficient margin" rejections.
   const handleMaxAmount = useCallback(() => {
     if (balanceForMax === 0) return;
     setOrderForm((prev) => ({
       ...prev,
-      amount: Math.floor(balanceForMax * prev.leverage).toString(),
+      amount: Math.floor(maxPossibleAmount).toString(),
     }));
-  }, [balanceForMax]);
+  }, [balanceForMax, maxPossibleAmount]);
 
   // Handle min amount selection
   const handleMinAmount = useCallback(() => {
diff --git a/app/components/UI/Perps/utils/orderCalculations.test.ts b/app/components/UI/Perps/utils/orderCalculations.test.ts
@@ -355,6 +355,27 @@ describe('orderCalculations', () => {
       expect(result).toBeGreaterThanOrEqual(0);
       expect(result).toBeLessThanOrEqual(50); // 10 * 5 leverage
     });
+
+    it('should apply margin buffer so result is below theoretical max', () => {
+      // Arrange - case where theoretical max is 1000 (100 * 10)
+      const params = {
+        availableBalance: 100,
+        assetPrice: 50000,
+        assetSzDecimals: 6,
+        leverage: 10,
+      };
+
+      // Act
+      const result = getMaxAllowedAmount(params);
+      const theoreticalMax = params.availableBalance * params.leverage;
+
+      // Assert - buffer (0.5%) reduces max to avoid "Insufficient margin" rejections
+      expect(result).toBeGreaterThan(0);
+      expect(result).toBeLessThanOrEqual(theoreticalMax);
+      expect(result).toBeLessThanOrEqual(
+        Math.floor(theoreticalMax * (1 - 0.005)),
+      );
+    });
   });
 
   describe('buildOrdersArray', () => {
diff --git a/app/controllers/perps/constants/perpsConfig.ts b/app/controllers/perps/constants/perpsConfig.ts
@@ -105,6 +105,14 @@ export const ORDER_SLIPPAGE_CONFIG = {
   DefaultLimitSlippageBps: 100,
 } as const;
 
+/**
+ * Max order amount buffer to reduce "Insufficient margin" rejections from the exchange.
+ * When the user selects 100% (slider or Max), we cap the order at (1 - this) of the
+ * theoretical max so that fees, rounding, and exchange-side margin checks are covered.
+ * Value as decimal (e.g. 0.005 = 0.5%).
+ */
+export const MAX_ORDER_MARGIN_BUFFER = 0.005; // 0.5%
+
 /**
  * Performance optimization constants
  * These values control debouncing and throttling for better performance
diff --git a/app/controllers/perps/utils/orderCalculations.ts b/app/controllers/perps/utils/orderCalculations.ts
@@ -4,7 +4,10 @@ import {
   formatHyperLiquidPrice,
   formatHyperLiquidSize,
 } from './hyperLiquidAdapter';
-import { ORDER_SLIPPAGE_CONFIG } from '../constants/perpsConfig';
+import {
+  MAX_ORDER_MARGIN_BUFFER,
+  ORDER_SLIPPAGE_CONFIG,
+} from '../constants/perpsConfig';
 import { PERPS_ERROR_CODES } from '../perpsErrorCodes';
 import type { PerpsDebugLogger } from '../types';
 import type { SDKOrderParams } from '../types/hyperliquid-types';
@@ -174,7 +177,11 @@ export function getMaxAllowedAmount(params: MaxAllowedAmountParams): number {
     maxAmount -= positionSizeIncrementUsd;
   }
 
-  return Math.max(0, maxAmount);
+  // Apply margin buffer to reduce "Insufficient margin" rejections from the exchange
+  // (fees, rounding, and exchange-side checks can make 100% theoretical max fail)
+  const bufferedMax = maxAmount * (1 - MAX_ORDER_MARGIN_BUFFER);
+
+  return Math.max(0, Math.floor(bufferedMax));
 }
 
 /**
