fix: guard against threshold underflow, stale CCIP amounts, and undefined FS chain service

Author: jintukumardas

packages/poller/src/init.ts

@@ -112,7 +112,21 @@ export const initPoller = async (): Promise<{ statusCode: number; body: string }
 
     logger.debug('Logging run mode of the instance', { runMode: process.env.RUN_MODE });
 
-    const rebalancer = getRegisteredRebalancers().find((r) => r.runMode === process.env.RUN_MODE);
+    const runMode = process.env.RUN_MODE;
+    const rebalancer = runMode ? getRegisteredRebalancers().find((r) => r.runMode === runMode) : undefined;
+
+    if (runMode && !rebalancer && runMode !== 'rebalanceOnly') {
+      const validModes = getRegisteredRebalancers().map((r) => r.runMode);
+      logger.error(`Unknown RUN_MODE "${runMode}". Valid modes: ${validModes.join(', ')}, rebalanceOnly`, {
+        runMode,
+        validModes,
+      });
+      return {
+        statusCode: 400,
+        body: JSON.stringify({ error: `Unknown RUN_MODE: ${runMode}` }),
+      };
+    }
+
     if (rebalancer) {
       logger.info(`Starting ${rebalancer.displayName} rebalancing`, {
         stage: config.stage,

packages/poller/src/rebalance/mantleEth.ts

@@ -942,8 +942,18 @@ async function processMethOperation(operation: RebalanceOperation, context: Proc
     operation.recipient!.toLowerCase() === config.methRebalance?.fillService?.address?.toLowerCase();
   const fillerSenderAddress =
     config.methRebalance?.fillService?.senderAddress ?? config.methRebalance?.fillService?.address;
+
+  if (isForFillService && !fillServiceChainService) {
+    logger.warn('Fill service chain service not available for FS operation callback, skipping', {
+      ...logContext,
+      recipientAddress: operation.recipient,
+      note: 'fillServiceChainService may not be configured in this deployment',
+    });
+    return;
+  }
+
   const evmSender = isForFillService ? fillerSenderAddress! : config.ownAddress;
-  const selectedChainService = isForFillService ? fillServiceChainService : chainService;
+  const selectedChainService = isForFillService ? fillServiceChainService! : chainService;
 
   // Check if ready for callback
   if (operation.status === RebalanceOperationStatus.PENDING) {

packages/poller/src/rebalance/solanaUsdc.ts

@@ -1,5 +1,5 @@
 import { TransactionReceipt as ViemTransactionReceipt } from 'viem';
-import { safeParseBigInt } from '../helpers';
+import { safeParseBigInt, getEvmBalance } from '../helpers';
 import { jsonifyError } from '@mark/logger';
 import {
   RebalanceOperationStatus,
@@ -709,14 +709,44 @@ async function executeLeg2And3(
 
     const ptUsdeAddress = tokenPair.ptUSDe;
 
+    // Use actual USDC balance on Mainnet instead of operation.amount to account for
+    // potential differences from CCIP fees or rounding during the cross-chain transfer
+    let swapAmount = operation.amount;
+    try {
+      const usdcBalance = await getEvmBalance(
+        rebalanceConfig,
+        MAINNET_CHAIN_ID.toString(),
+        recipient,
+        usdcAddress,
+        USDC_SOLANA_DECIMALS,
+        context.prometheus,
+      );
+      const operationAmount = safeParseBigInt(operation.amount);
+      if (usdcBalance < operationAmount) {
+        logger.warn('Actual USDC balance on Mainnet is less than operation amount (CCIP fees/rounding)', {
+          ...logContext,
+          operationAmount: operation.amount,
+          actualBalance: usdcBalance.toString(),
+          difference: (operationAmount - usdcBalance).toString(),
+        });
+        swapAmount = usdcBalance.toString();
+      }
+    } catch (balanceError) {
+      logger.warn('Failed to check actual USDC balance on Mainnet, using operation amount', {
+        ...logContext,
+        error: jsonifyError(balanceError),
+        fallbackAmount: operation.amount,
+      });
+    }
+
     logger.debug('Leg 2 Pendle swap details', {
       ...logContext,
       storedRecipient,
       fallbackRecipient: rebalanceConfig.ownAddress,
       finalRecipient: recipient,
       usdcAddress,
       ptUsdeAddress,
-      amountToSwap: operation.amount,
+      amountToSwap: swapAmount,
     });
 
     // Create route for USDC → ptUSDe swap on mainnet (same chain swap)
@@ -728,17 +758,17 @@ async function executeLeg2And3(
     };
 
     // Get quote from Pendle for USDC → ptUSDe
-    const receivedAmountStr = await pendleAdapter.getReceivedAmount(operation.amount, pendleRoute);
+    const receivedAmountStr = await pendleAdapter.getReceivedAmount(swapAmount, pendleRoute);
 
     logger.info('Received Pendle quote for USDC → ptUSDe swap', {
       ...logContext,
-      amountToSwap: operation.amount,
+      amountToSwap: swapAmount,
       expectedPtUsde: receivedAmountStr,
       route: pendleRoute,
     });
 
     // Execute the Pendle swap transactions
-    const swapTxRequests = await pendleAdapter.send(recipient, recipient, operation.amount, pendleRoute);
+    const swapTxRequests = await pendleAdapter.send(recipient, recipient, swapAmount, pendleRoute);
 
     if (!swapTxRequests.length) {
       logger.error('No swap transactions returned from Pendle adapter', logContext);
@@ -874,9 +904,9 @@ async function executeLeg2And3(
       status: RebalanceOperationStatus.CANCELLED,
     });
 
-    logger.info('Marked operation as FAILED due to Leg 2/3 failure', {
+    logger.info('Marked operation as CANCELLED due to Leg 2/3 failure', {
       ...logContext,
-      note: 'Funds are on Mainnet as USDC - manual intervention may be required',
+      note: 'Funds are on Mainnet as USDC or ptUSDe (depending on which leg failed) - manual intervention required',
     });
   }
 }

packages/poller/src/rebalance/thresholdEngine.ts

@@ -88,6 +88,16 @@ export async function runThresholdRebalance(
 
   // 4. Threshold comparison
   const { threshold, target } = descriptor.getThresholds();
+
+  if (target < threshold) {
+    logger.error(`${name} misconfiguration: target (${target.toString()}) is less than threshold (${threshold.toString()})`, {
+      requestId,
+      threshold: threshold.toString(),
+      target: target.toString(),
+    });
+    return [];
+  }
+
   logger.info(`${name} threshold check`, {
     requestId,
     recipientBalance: recipientBalance.toString(),
@@ -106,7 +116,12 @@ export async function runThresholdRebalance(
   }
 
   // 5. Compute shortfall and convert to bridge amount
-  const shortfall = target - recipientBalance;
+  // Clamp to 0n to guard against edge cases where recipientBalance > target but < threshold
+  const shortfall = recipientBalance < target ? target - recipientBalance : 0n;
+  if (shortfall === 0n) {
+    logger.info(`${name} recipient balance above target, no shortfall`, { requestId });
+    return [];
+  }
   let bridgeAmount: bigint;
   try {
     bridgeAmount = await descriptor.convertShortfallToBridgeAmount(shortfall, context);