Merge pull request #58 from anoncon/feat/issue-36-stellar-dex-rebalance

Implement real Stellar DEX rebalance execution with slippage controls

Author: ritik4ever

backend/.env.example

@@ -27,6 +27,17 @@ STELLAR_HORIZON_URL=https://horizon-testnet.stellar.org
 # Replace with your actual deployed contract address
 STELLAR_CONTRACT_ADDRESS=CDEMOCONTRACTADDRESS123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ
 
+# Secret used by backend to sign DEX rebalance transactions.
+# Use a testnet account secret only.
+STELLAR_REBALANCE_SECRET=
+
+# Allow signer account mismatch with portfolio user address (not recommended)
+REBALANCE_ALLOW_SIGNER_MISMATCH=false
+
+# Optional JSON map for non-native assets used in rebalancing
+# Example: {"USDC":"G...","BTC":"G...","ETH":"G..."}
+STELLAR_ASSET_ISSUERS={"USDC":"GBBD47IF6LWK7P7MDEVSCWR7DPUWV3NY3DTQEVFL4NAT4AQH3ZLLFLA5","BTC":"GAUTUYY2THLF7SGITDFMXJVYH3LHDSMGEAKSBU267M2K7A3W543CKUEF"}
+
 # ============================================
 # PRICE FEED CONFIGURATION
 # ============================================
@@ -79,6 +90,14 @@ MAX_TRADE_SIZE_PERCENTAGE=25
 # Minimum trade size (USD)
 MIN_TRADE_SIZE_USD=10
 
+# Rebalance execution safety controls
+REBALANCE_MAX_TRADE_SLIPPAGE_BPS=100
+REBALANCE_MAX_TOTAL_SLIPPAGE_BPS=250
+REBALANCE_MAX_SPREAD_BPS=120
+REBALANCE_MIN_LIQUIDITY_COVERAGE=1.0
+REBALANCE_ALLOW_PARTIAL_FILL=true
+REBALANCE_ROLLBACK_ON_FAILURE=true
+
 # ============================================
 # NOTIFICATION CONFIGURATION
 # ============================================

backend/src/api/routes.ts

@@ -47,6 +47,33 @@ const getPortfolioAllocationsAsRecord = (portfolio: any): Record<string, number>
     return portfolio.allocations as Record<string, number>
 }
 
+const parseOptionalNumber = (value: unknown): number | undefined => {
+    if (value === undefined || value === null || value === '') return undefined
+    const parsed = Number(value)
+    return Number.isFinite(parsed) ? parsed : undefined
+}
+
+const parseOptionalBoolean = (value: unknown): boolean | undefined => {
+    if (value === undefined || value === null || value === '') return undefined
+    if (typeof value === 'boolean') return value
+    if (typeof value === 'string') {
+        const lower = value.toLowerCase()
+        if (lower === 'true') return true
+        if (lower === 'false') return false
+    }
+    return undefined
+}
+
+const parseSlippageOverrides = (value: unknown): Record<string, number> | undefined => {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) return undefined
+    const parsed: Record<string, number> = {}
+    for (const [key, raw] of Object.entries(value as Record<string, unknown>)) {
+        const num = parseOptionalNumber(raw)
+        if (num !== undefined) parsed[key] = num
+    }
+    return Object.keys(parsed).length > 0 ? parsed : undefined
+}
+
 // ================================
 // HEALTH CHECK ROUTES
 // ================================
@@ -237,7 +264,18 @@ router.post('/portfolio/:id/rebalance', writeRateLimiter, async (req, res) => {
             })
         }
 
-        const result = await stellarService.executeRebalance(portfolioId)
+        const executionOptions = {
+            tradeSlippageBps: parseOptionalNumber(req.body?.tradeSlippageBps),
+            maxSlippageBpsPerRebalance: parseOptionalNumber(req.body?.maxSlippageBpsPerRebalance),
+            maxSpreadBps: parseOptionalNumber(req.body?.maxSpreadBps),
+            minLiquidityCoverage: parseOptionalNumber(req.body?.minLiquidityCoverage),
+            allowPartialFill: parseOptionalBoolean(req.body?.allowPartialFill),
+            rollbackOnFailure: parseOptionalBoolean(req.body?.rollbackOnFailure),
+            signerSecret: typeof req.body?.signerSecret === 'string' ? req.body.signerSecret : undefined,
+            tradeSlippageOverrides: parseSlippageOverrides(req.body?.tradeSlippageOverrides)
+        }
+
+        const result = await stellarService.executeRebalance(portfolioId, executionOptions)
 
         await analyticsService.captureSnapshot(portfolioId, prices)
 
@@ -246,40 +284,51 @@ router.post('/portfolio/:id/rebalance', writeRateLimiter, async (req, res) => {
             trigger: 'Manual Rebalance',
             trades: result.trades || 0,
             gasUsed: result.gasUsed || '0 XLM',
-            status: 'completed',
+            status: result.status === 'failed' ? 'failed' : 'completed',
             isAutomatic: false,
-            riskAlerts: riskCheck.alerts
+            riskAlerts: riskCheck.alerts,
+            error: result.failureReasons?.join('; ')
         })
 
-        // Send notification for manual rebalance
-        try {
-            await notificationService.notify({
-                userId: portfolio.userAddress,
-                eventType: 'rebalance',
-                title: 'Portfolio Rebalanced',
-                message: `Your portfolio has been manually rebalanced. ${result.trades || 0} trades executed with ${result.gasUsed || '0 XLM'} gas used.`,
-                data: {
+        // Send notification for successful/partial manual rebalance
+        if (result.status !== 'failed') {
+            try {
+                await notificationService.notify({
+                    userId: portfolio.userAddress,
+                    eventType: 'rebalance',
+                    title: result.status === 'partial' ? 'Portfolio Partially Rebalanced' : 'Portfolio Rebalanced',
+                    message: `Your portfolio has been manually rebalanced. ${result.trades || 0} trades executed with ${result.gasUsed || '0 XLM'} gas used.`,
+                    data: {
+                        portfolioId,
+                        trades: result.trades,
+                        gasUsed: result.gasUsed,
+                        trigger: 'manual',
+                        status: result.status
+                    },
+                    timestamp: new Date().toISOString()
+                })
+            } catch (notificationError) {
+                logger.error('Failed to send rebalance notification', {
                     portfolioId,
-                    trades: result.trades,
-                    gasUsed: result.gasUsed,
-                    trigger: 'manual'
-                },
-                timestamp: new Date().toISOString()
-            })
-        } catch (notificationError) {
-            logger.error('Failed to send rebalance notification', {
-                portfolioId,
-                error: getErrorObject(notificationError)
-            })
+                    error: getErrorObject(notificationError)
+                })
+            }
         }
 
         logger.info('Rebalance executed successfully', { portfolioId, result })
-        res.json({
+        const responseStatus = result.status === 'failed' ? 409 : 200
+        res.status(responseStatus).json({
             result,
-            status: 'completed',
+            status: result.status === 'failed' ? 'failed' : 'completed',
             mode: 'demo',
-            message: 'Rebalance completed successfully',
-            riskAlerts: riskCheck.alerts
+            message: result.status === 'failed'
+                ? 'Rebalance execution failed safely'
+                : result.status === 'partial'
+                    ? 'Rebalance partially completed'
+                    : 'Rebalance completed successfully',
+            riskAlerts: riskCheck.alerts,
+            failureReasons: result.failureReasons || [],
+            partialFills: result.partialFills || []
         })
     } catch (error) {
         logger.error('Rebalance failed', { error: getErrorObject(error), portfolioId: req.params.id })
@@ -1367,4 +1416,4 @@ router.get('/debug/auto-rebalancer-test', blockDebugInProduction, async (req, re
     }
 })
 
-export { router as portfolioRouter }
+export { router as portfolioRouter }

backend/src/monitoring/rebalancer.ts

@@ -84,12 +84,21 @@ export class RebalancingService {
                     if (this.shouldAutoRebalance(portfolio, riskAlerts)) {
                         logger.info(`Auto-executing rebalance for portfolio ${portfolioId}`)
                         try {
-                            await this.stellarService.executeRebalance(portfolioId)
-
-                            this.notifyClients(portfolioId, 'rebalance_completed', {
-                                message: 'Automatic rebalancing completed successfully',
-                                riskLevel: 'low'
-                            })
+                            const rebalanceResult = await this.stellarService.executeRebalance(portfolioId)
+                            if (rebalanceResult.status === 'failed') {
+                                this.notifyClients(portfolioId, 'rebalance_failed', {
+                                    message: 'Automatic rebalancing failed safely',
+                                    reasons: rebalanceResult.failureReasons || []
+                                })
+                            } else {
+                                this.notifyClients(portfolioId, 'rebalance_completed', {
+                                    message: rebalanceResult.status === 'partial'
+                                        ? 'Automatic rebalancing partially completed'
+                                        : 'Automatic rebalancing completed successfully',
+                                    riskLevel: 'low',
+                                    status: rebalanceResult.status
+                                })
+                            }
                         } catch (rebalanceError) {
                             logger.error(`Auto-rebalance failed for ${portfolioId}:`, rebalanceError)
 
@@ -272,4 +281,4 @@ export class RebalancingService {
             riskManagement: { enabled: true, lastUpdate: new Date().toISOString() }
         }
     }
-}
+}

backend/src/services/autoRebalancer.ts

@@ -200,42 +200,59 @@ export class AutoRebalancerService {
                 trigger: 'automatic_drift_detection'
             })
 
-            const rebalanceResult = await this.stellarService.executeRebalance(portfolioId)
-
-            // Record the auto-rebalance event
-            await this.rebalanceHistoryService.recordRebalanceEvent({
-                portfolioId,
-                trigger: 'Automatic Rebalancing',
-                trades: rebalanceResult.trades || 0,
-                gasUsed: rebalanceResult.gasUsed || '0 XLM',
-                status: 'completed',
-                isAutomatic: true,
-                riskAlerts: riskCheck.alerts || []
-            })
-
-            // Send notification for successful auto-rebalance
-            try {
-                await notificationService.notify({
-                    userId: portfolio.userAddress,
-                    eventType: 'rebalance',
-                    title: 'Portfolio Rebalanced',
-                    message: `Your portfolio has been automatically rebalanced. ${rebalanceResult.trades || 0} trades executed with ${rebalanceResult.gasUsed || '0 XLM'} gas used.`,
-                    data: {
-                        portfolioId,
-                        trades: rebalanceResult.trades,
-                        gasUsed: rebalanceResult.gasUsed,
-                        trigger: 'automatic'
-                    },
-                    timestamp: new Date().toISOString()
-                })
-            } catch (notificationError) {
-                logger.error('Failed to send rebalance notification', {
+            const rebalanceResult = await this.stellarService.executeRebalance(portfolioId)
+            const rebalanceSucceeded = rebalanceResult.status !== 'failed'
+
+            // Record the auto-rebalance event
+            await this.rebalanceHistoryService.recordRebalanceEvent({
+                portfolioId,
+                trigger: 'Automatic Rebalancing',
+                trades: rebalanceResult.trades || 0,
+                gasUsed: rebalanceResult.gasUsed || '0 XLM',
+                status: rebalanceSucceeded ? 'completed' : 'failed',
+                isAutomatic: true,
+                riskAlerts: riskCheck.alerts || [],
+                error: rebalanceResult.failureReasons?.join('; ')
+            })
+
+            if (!rebalanceSucceeded) {
+                return {
+                    rebalanced: false,
+                    reason: rebalanceResult.failureReasons?.[0] || 'Execution failed'
+                }
+            }
+
+            // Send notification for successful auto-rebalance
+            try {
+                await notificationService.notify({
+                    userId: portfolio.userAddress,
+                    eventType: 'rebalance',
+                    title: rebalanceResult.status === 'partial'
+                        ? 'Portfolio Partially Rebalanced'
+                        : 'Portfolio Rebalanced',
+                    message: `Your portfolio has been automatically rebalanced. ${rebalanceResult.trades || 0} trades executed with ${rebalanceResult.gasUsed || '0 XLM'} gas used.`,
+                    data: {
+                        portfolioId,
+                        trades: rebalanceResult.trades,
+                        gasUsed: rebalanceResult.gasUsed,
+                        trigger: 'automatic',
+                        status: rebalanceResult.status
+                    },
+                    timestamp: new Date().toISOString()
+                })
+            } catch (notificationError) {
+                logger.error('Failed to send rebalance notification', {
                     portfolioId,
                     error: notificationError instanceof Error ? notificationError.message : String(notificationError)
                 })
             }
 
-            return { rebalanced: true, reason: 'Successfully auto-rebalanced' }
+            return {
+                rebalanced: true,
+                reason: rebalanceResult.status === 'partial'
+                    ? 'Partially auto-rebalanced'
+                    : 'Successfully auto-rebalanced'
+            }
 
         } catch (error) {
             logger.error('[AUTO-REBALANCER] Error executing rebalance', {
@@ -367,4 +384,4 @@ export class AutoRebalancerService {
             }
         }
     }
-}
+}