feat: add general configs and tests

Author: Hakob23

internal/adapters/entrypoints/rest/assets/static/management.js

@@ -2,6 +2,8 @@ import {
     weiToEther,
     etherToWei,
     isFeeKey,
+    isMaxLiquidityKey,
+    validateMaxLiquidity,
     validateConfig,
     formatGeneralConfig,
     postConfig,
@@ -49,7 +51,12 @@ const createInput = (section, key, value) => {
 
     const label = document.createElement('label');
     label.classList.add('form-label');
-    label.textContent = key;
+    label.textContent = getDisplayLabel(key);
+    
+    // Make Maximum Liquidity label bold
+    if (isMaxLiquidityKey(key)) {
+        label.style.fontWeight = 'bold';
+    }
 
     const inputContainer = document.createElement('div');
     inputContainer.classList.add('input-container');
@@ -139,8 +146,11 @@ const createFeeInput = (inputContainer, label, section, key, value) => {
     input.value = isFeeKey(key) ? weiToEther(value) : value;
     input.addEventListener('input', () => setChanged(section.id));
     inputContainer.appendChild(input);
-    const questionIcon = createQuestionIcon(getTooltipText(key));
-    label.appendChild(questionIcon);
+    // Skip tooltip for maxLiquidity
+    if (!isMaxLiquidityKey(key)) {
+        const questionIcon = createQuestionIcon(getTooltipText(key));
+        label.appendChild(questionIcon);
+    }
 };
 
 const createFeePercentageInput = (inputContainer, section, key, value) => {
@@ -184,6 +194,13 @@ const createQuestionIcon = (tooltipText) => {
     return questionIcon;
 };
 
+const getDisplayLabel = (key) => {
+    const labels = {
+        maxLiquidity: 'Maximum Liquidity'
+    };
+    return labels[key] || key;
+};
+
 const getTooltipText = (key) => {
     const tooltips = {
         timeForDeposit: 'The time (in seconds) for which a deposit is considered valid.',
@@ -195,7 +212,8 @@ const getTooltipText = (key) => {
         expireBlocks: 'The number of blocks after which a quote is considered expired.',
         bridgeTransactionMin: 'The amount of rBTC that needs to be gathered in peg out refunds before executing a native peg out.',
         fixedFee: 'A fixed fee charged for transactions.',
-        feePercentage: 'A percentage fee charged based on the transaction amount.'
+        feePercentage: 'A percentage fee charged based on the transaction amount.',
+        maxLiquidity: 'The maximum liquidity (in rBTC) the provider is willing to offer. Must be a positive value with up to 18 decimal places.'
     };
     return tooltips[key] || 'No description available';
 };
@@ -472,7 +490,20 @@ function getRegularConfig(sectionId) {
                 value = '0';
             }
         } else {
-            if (isFeeKey(key)) {
+            if (isMaxLiquidityKey(key)) {
+                // Validate maxLiquidity: must be positive and max 18 decimal places
+                const validation = validateMaxLiquidity(input.value);
+                if (!validation.isValid) {
+                    showErrorToast(`"${sectionId}": ${validation.error}`);
+                    throw new Error(validation.error);
+                }
+                try {
+                    value = etherToWei(input.value).toString();
+                } catch (error) {
+                    showErrorToast(`"${sectionId}": Invalid input "${input.value}" for field "${key}". Please enter a valid number.`);
+                    throw error;
+                }
+            } else if (isFeeKey(key)) {
                 try {
                     value = etherToWei(input.value).toString();
                 } catch (error) {

internal/adapters/entrypoints/rest/handlers/set_general_config_test.go

@@ -97,6 +97,33 @@ func TestSetGeneralConfigHandler(t *testing.T) {
 		assert.Equal(t, http.StatusBadRequest, w.Code)
 		useCase.AssertNotCalled(t, "Run")
 	})
+	t.Run("should return bad request if maxLiquidity has decimal places", func(t *testing.T) {
+		useCase := new(mocks.SetGeneralConfigUseCaseMock)
+
+		handler := handlers.NewSetGeneralConfigHandler(useCase)
+		// Backend expects wei values (integers), so decimal values should fail
+		reqBody := `{"configuration": {"btcConfirmations": {"5": 10}, "rskConfirmations": {"10": 20}, "publicLiquidityCheck": true, "maxLiquidity": "1000.5"}}`
+		req := httptest.NewRequest(http.MethodPost, "/configuration", strings.NewReader(reqBody))
+		req.Header.Set("Content-Type", "application/json")
+		w := httptest.NewRecorder()
+		handler(w, req)
+		assert.Equal(t, http.StatusBadRequest, w.Code)
+		useCase.AssertNotCalled(t, "Run")
+	})
+	t.Run("should return success with maxLiquidity having 18 digits precision", func(t *testing.T) {
+		useCase := new(mocks.SetGeneralConfigUseCaseMock)
+		useCase.EXPECT().Run(mock.Anything, mock.Anything).Return(nil)
+
+		handler := handlers.NewSetGeneralConfigHandler(useCase)
+		// 1 RBTC in wei (18 decimal places) - valid large integer
+		reqBody := `{"configuration": {"btcConfirmations": {"5": 10}, "rskConfirmations": {"10": 20}, "publicLiquidityCheck": true, "maxLiquidity": "1000000000000000000"}}`
+		req := httptest.NewRequest(http.MethodPost, "/configuration", strings.NewReader(reqBody))
+		req.Header.Set("Content-Type", "application/json")
+		w := httptest.NewRecorder()
+		handler(w, req)
+		assert.Equal(t, http.StatusNoContent, w.Code)
+		useCase.AssertExpectations(t)
+	})
 	t.Run("should return server internal error if the use case fails", func(t *testing.T) {
 		useCase := new(mocks.SetGeneralConfigUseCaseMock)
 		useCase.EXPECT().Run(mock.Anything, mock.Anything).Return(assert.AnError)

pkg/liquidity_provider_test.go

@@ -682,6 +682,36 @@ func TestFromGeneralConfigurationDTO(t *testing.T) {
 		assert.Empty(t, config)
 		require.ErrorContains(t, err, "cannot deserialize RSK confirmations key invalid")
 	})
+
+	t.Run("handles maxLiquidity with 18-digit precision correctly", func(t *testing.T) {
+		// 1 RBTC = 1000000000000000000 wei (18 zeros)
+		dto := pkg.GeneralConfigurationDTO{
+			RskConfirmations:     map[string]uint16{"1000000000000000000": 5},
+			BtcConfirmations:     map[string]uint16{"1000000000000000000": 10},
+			PublicLiquidityCheck: true,
+			MaxLiquidity:         "1000000000000000000",
+		}
+
+		config, err := pkg.FromGeneralConfigurationDTO(dto)
+
+		require.NoError(t, err)
+		assert.Equal(t, "1000000000000000000", config.MaxLiquidity.String())
+	})
+
+	t.Run("handles very large maxLiquidity values", func(t *testing.T) {
+		// 100 RBTC = 100 * 10^18 wei
+		dto := pkg.GeneralConfigurationDTO{
+			RskConfirmations:     map[string]uint16{"1000000000000000000": 5},
+			BtcConfirmations:     map[string]uint16{"1000000000000000000": 10},
+			PublicLiquidityCheck: false,
+			MaxLiquidity:         "100000000000000000000",
+		}
+
+		config, err := pkg.FromGeneralConfigurationDTO(dto)
+
+		require.NoError(t, err)
+		assert.Equal(t, "100000000000000000000", config.MaxLiquidity.String())
+	})
 }
 
 func TestToBtcAssetLocationDTO(t *testing.T) {