fix: bugs, logging and tests for rebalancer engines

Author: jintukumardas

packages/adapters/rebalance/src/actions/dex-swap.ts

@@ -149,12 +149,15 @@ export class DexSwapActionHandler implements PostBridgeActionHandler {
       args: [sender as `0x${string}`, spender as `0x${string}`],
     });
 
-    if (allowance < swapAmount) {
+    const approvalAmount = swapAmount + (swapAmount * BigInt(slippageBps)) / BigInt(10000);
+    if (allowance < approvalAmount) {
       this.logger.info('DexSwap: building approval transaction', {
         sellToken,
         spender,
         currentAllowance: allowance.toString(),
-        requiredAmount: swapAmount.toString(),
+        approvalAmount: approvalAmount.toString(),
+        swapAmount: swapAmount.toString(),
+        slippageBps,
         destinationChainId,
       });
 
@@ -165,7 +168,7 @@ export class DexSwapActionHandler implements PostBridgeActionHandler {
           data: encodeFunctionData({
             abi: erc20Abi,
             functionName: 'approve',
-            args: [spender as `0x${string}`, swapAmount + (swapAmount * BigInt(slippageBps)) / BigInt(10000)],
+            args: [spender as `0x${string}`, approvalAmount],
           }),
           value: BigInt(0),
         },
@@ -175,7 +178,7 @@ export class DexSwapActionHandler implements PostBridgeActionHandler {
         sellToken,
         spender,
         currentAllowance: allowance.toString(),
-        requiredAmount: swapAmount.toString(),
+        requiredAmount: approvalAmount.toString(),
         destinationChainId,
       });
     }

packages/adapters/rebalance/src/adapters/zircuit/zircuit.ts

@@ -408,40 +408,44 @@ export class ZircuitNativeBridgeAdapter implements BridgeAdapter {
   }
 
   async isCallbackComplete(route: RebalanceRoute, originTransaction: TransactionReceipt): Promise<boolean> {
-    const isL1ToL2 = route.origin === ETHEREUM_CHAIN_ID && route.destination === ZIRCUIT_CHAIN_ID;
-    const isL2ToL1 = route.origin === ZIRCUIT_CHAIN_ID && route.destination === ETHEREUM_CHAIN_ID;
-    if (!isL1ToL2 && !isL2ToL1) {
-      throw new Error(`Unsupported Zircuit route: ${route.origin}->${route.destination}`);
-    }
-    if (isL1ToL2) {
-      return true;
-    }
+    try {
+      const isL1ToL2 = route.origin === ETHEREUM_CHAIN_ID && route.destination === ZIRCUIT_CHAIN_ID;
+      const isL2ToL1 = route.origin === ZIRCUIT_CHAIN_ID && route.destination === ETHEREUM_CHAIN_ID;
+      if (!isL1ToL2 && !isL2ToL1) {
+        throw new Error(`Unsupported Zircuit route: ${route.origin}->${route.destination}`);
+      }
+      if (isL1ToL2) {
+        return true;
+      }
 
-    // L2→L1: complete only when finalized
-    const l1Client = await this.getClient(ETHEREUM_CHAIN_ID);
-    const l2Client = await this.getClient(ZIRCUIT_CHAIN_ID);
+      // L2→L1: complete only when finalized
+      const l1Client = await this.getClient(ETHEREUM_CHAIN_ID);
+      const l2Client = await this.getClient(ZIRCUIT_CHAIN_ID);
 
-    const withdrawalTx = await this.extractWithdrawalTransaction(l2Client, originTransaction);
-    if (!withdrawalTx) {
-      // Cannot determine state — treat as complete to avoid stuck entries
-      return true;
-    }
+      const withdrawalTx = await this.extractWithdrawalTransaction(l2Client, originTransaction);
+      if (!withdrawalTx) {
+        // Cannot determine state — treat as complete to avoid stuck entries
+        return true;
+      }
 
-    const withdrawalHash = this.hashWithdrawal(withdrawalTx);
-    const isFinalized = await l1Client.readContract({
-      address: ZIRCUIT_OPTIMISM_PORTAL as `0x${string}`,
-      abi: zircuitOptimismPortalAbi,
-      functionName: 'finalizedWithdrawals',
-      args: [withdrawalHash],
-    });
+      const withdrawalHash = this.hashWithdrawal(withdrawalTx);
+      const isFinalized = await l1Client.readContract({
+        address: ZIRCUIT_OPTIMISM_PORTAL as `0x${string}`,
+        abi: zircuitOptimismPortalAbi,
+        functionName: 'finalizedWithdrawals',
+        args: [withdrawalHash],
+      });
 
-    this.logger.info('Zircuit isCallbackComplete check', {
-      txHash: originTransaction.transactionHash,
-      withdrawalHash,
-      isFinalized,
-    });
+      this.logger.info('Zircuit isCallbackComplete check', {
+        txHash: originTransaction.transactionHash,
+        withdrawalHash,
+        isFinalized,
+      });
 
-    return isFinalized as boolean;
+      return isFinalized as boolean;
+    } catch (error) {
+      this.handleError(error, 'check if callback is complete', { route, originTransaction });
+    }
   }
 
   private async getClient(chainId: number): Promise<PublicClient> {

packages/adapters/rebalance/test/actions/dex-swap.spec.ts

@@ -236,7 +236,7 @@ describe('DexSwapActionHandler', () => {
     const customEstOutput = '9999999999999999999';
     mockReadContract
       .mockResolvedValueOnce(BigInt(1000000) as never) // balanceOf
-      .mockResolvedValueOnce(BigInt(1000000) as never); // allowance (sufficient)
+      .mockResolvedValueOnce(BigInt(1010000) as never); // allowance (sufficient including slippage padding)
 
     axiosPostMock.mockResolvedValueOnce({
       data: {

packages/agent/src/adapters.ts

@@ -70,6 +70,8 @@ export function initializeBaseAdapters(
   const fsSenderAddress =
     config.tacRebalance?.fillService?.senderAddress ??
     config.tacRebalance?.fillService?.address ??
+    config.methRebalance?.fillService?.senderAddress ??
+    config.methRebalance?.fillService?.address ??
     config.aManUsdeRebalance?.fillService?.senderAddress ??
     config.aManUsdeRebalance?.fillService?.address ??
     config.aMansyrupUsdtRebalance?.fillService?.senderAddress ??

packages/poller/src/rebalance/aaveTokenRebalancer.ts

@@ -17,12 +17,13 @@ import {
 } from '@mark/core';
 import { ProcessingContext } from '../init';
 import { submitTransactionWithLogging } from '../helpers/transactions';
-import { RebalanceTransactionMemo, buildTransactionsForAction } from '@mark/rebalance';
-import { createRebalanceOperation, TransactionReceipt } from '@mark/database';
+import { buildTransactionsForAction } from '@mark/rebalance';
+import { TransactionReceipt } from '@mark/database';
 import { getBridgeTypeFromTag } from './helpers';
 import { RebalanceRunState } from './types';
 import { runThresholdRebalance, ThresholdRebalanceDescriptor } from './thresholdEngine';
 import { runCallbackLoop, RebalanceOperation } from './callbackEngine';
+import { executeEvmBridge } from './bridgeExecution';
 
 /**
  * Descriptor that parameterizes the generic Aave token rebalancer for a specific flow.
@@ -252,13 +253,12 @@ export const executeStargateBridgeForAaveToken = async (
   const { config, chainService, fillServiceChainService, logger, requestId, rebalance } = context;
   const tokenConfig = descriptor.getConfig(config)!;
   const bridgeConfig = tokenConfig.bridge;
-  const actions: RebalanceAction[] = [];
 
   const bridgeType = SupportedBridge.Stargate;
   const adapter = rebalance.getAdapter(bridgeType);
   if (!adapter) {
     logger.error('Stargate adapter not found', { requestId });
-    return actions;
+    return [];
   }
 
   // Select the correct chain service based on whether the sender is the fill service address
@@ -273,7 +273,7 @@ export const executeStargateBridgeForAaveToken = async (
       senderAddress,
       fillerSenderAddress,
     });
-    return actions;
+    return [];
   }
 
   const sourceTokenAddress = getTokenAddressFromConfig(descriptor.sourceTokenTickerHash, MAINNET_CHAIN_ID, config)!;
@@ -300,122 +300,37 @@ export const executeStargateBridgeForAaveToken = async (
   });
 
   try {
-    // Get quote
-    const receivedAmountStr = await adapter.getReceivedAmount(amount.toString(), route);
-    logger.info('Received Stargate quote', {
-      requestId,
-      amountToBridge: amount.toString(),
-      receivedAmount: receivedAmountStr,
-    });
-
-    // Check slippage
-    const receivedAmount = BigInt(receivedAmountStr);
-    const slippage = BigInt(slippageDbps);
-    const minimumAcceptableAmount = amount - (amount * slippage) / DBPS_MULTIPLIER;
-
-    if (receivedAmount < minimumAcceptableAmount) {
-      logger.warn('Stargate quote does not meet slippage requirements', {
-        requestId,
-        amountToBridge: amount.toString(),
-        receivedAmount: receivedAmount.toString(),
-        minimumAcceptableAmount: minimumAcceptableAmount.toString(),
-        slippageDbps,
-      });
-      return actions;
-    }
-
-    // Get bridge transactions
-    const bridgeTxRequests = await adapter.send(senderAddress, recipientAddress, amount.toString(), route);
-    if (!bridgeTxRequests.length) {
-      logger.error('No bridge transactions returned from Stargate adapter', { requestId });
-      return actions;
-    }
-
-    logger.info('Prepared Stargate bridge transactions', {
-      requestId,
-      transactionCount: bridgeTxRequests.length,
-    });
-
-    // Execute bridge transactions
-    let receipt: TransactionReceipt | undefined;
-    let effectiveBridgedAmount = amount.toString();
-
-    for (const { transaction, memo, effectiveAmount } of bridgeTxRequests) {
-      logger.info('Submitting Stargate bridge transaction', {
-        requestId,
-        memo,
-        to: transaction.to,
-      });
-
-      const result = await submitTransactionWithLogging({
-        chainService: selectedChainService,
-        logger,
-        chainId: MAINNET_CHAIN_ID,
-        txRequest: {
-          to: transaction.to!,
-          data: transaction.data!,
-          value: (transaction.value || 0).toString(),
-          chainId: Number(MAINNET_CHAIN_ID),
-          from: senderAddress,
-          funcSig: transaction.funcSig || '',
-        },
-        zodiacConfig: { walletType: WalletType.EOA },
-        context: { requestId, route, bridgeType, transactionType: memo },
-      });
-
-      logger.info('Successfully submitted Stargate bridge transaction', {
-        requestId,
-        memo,
-        transactionHash: result.hash,
-      });
-
-      if (memo === RebalanceTransactionMemo.Rebalance) {
-        receipt = result.receipt! as unknown as TransactionReceipt;
-        if (effectiveAmount) {
-          effectiveBridgedAmount = effectiveAmount;
-        }
-      }
-    }
-
-    // Create database record
-    await createRebalanceOperation({
-      earmarkId: null,
-      originChainId: route.origin,
-      destinationChainId: route.destination,
-      tickerHash: descriptor.sourceTokenTickerHash,
-      amount: effectiveBridgedAmount,
-      slippage: slippageDbps,
-      status: RebalanceOperationStatus.PENDING,
-      bridge: descriptor.bridgeTag,
-      transactions: receipt ? { [MAINNET_CHAIN_ID]: receipt } : undefined,
-      recipient: recipientAddress,
-    });
-
-    logger.info(`Successfully created ${descriptor.name} rebalance operation`, {
-      requestId,
-      originTxHash: receipt?.transactionHash,
-      amountToBridge: effectiveBridgedAmount,
-      bridge: descriptor.bridgeTag,
-    });
-
-    actions.push({
-      bridge: bridgeType,
-      amount: amount.toString(),
-      origin: route.origin,
-      destination: route.destination,
-      asset: route.asset,
-      transaction: receipt?.transactionHash || '',
+    const result = await executeEvmBridge({
+      context,
+      adapter,
+      route,
+      amount,
+      sender: senderAddress,
       recipient: recipientAddress,
+      slippageTolerance: BigInt(slippageDbps),
+      slippageMultiplier: DBPS_MULTIPLIER,
+      chainService: selectedChainService,
+      senderConfig: {
+        address: senderAddress,
+        label: isFillerSender ? 'fill-service' : 'market-maker',
+      },
+      dbRecord: {
+        earmarkId: null,
+        tickerHash: descriptor.sourceTokenTickerHash,
+        bridgeTag: descriptor.bridgeTag,
+        status: RebalanceOperationStatus.PENDING,
+      },
+      label: `Stargate ${descriptor.name}`,
     });
+    return result.actions;
   } catch (error) {
     logger.error(`Failed to execute Stargate bridge for ${descriptor.name}`, {
       requestId,
       route,
       error: jsonifyError(error),
     });
+    return [];
   }
-
-  return actions;
 };
 
 /**
@@ -468,11 +383,12 @@ async function processAaveTokenOperation(
   const selectedChainService = isForFillService && fillServiceChainService ? fillServiceChainService : chainService;
 
   if (isForFillService && !fillServiceChainService) {
-    logger.warn(`Fill service chain service not available for ${descriptor.name} callback, using main chain service`, {
+    logger.error(`Fill service chain service not available for ${descriptor.name} callback, skipping`, {
       ...logContext,
       recipient: operation.recipient,
       fsAddress,
     });
+    return;
   }
 
   const bridgeType = operation.bridge ? getBridgeTypeFromTag(operation.bridge) : undefined;