@humanode-hyperlane/rebalancer 27.2.2 → 1029.1.0

package/src/core/InventoryRebalancer.ts

@@ -3,14 +3,12 @@ import type { Logger } from 'pino';
 import {
   type ChainName,
   HyperlaneCore,
-  type InterchainGasQuote,
   type MultiProtocolSignerSignerAccountInfo,
   type MultiProvider,
-  Token,
   ProviderType,
   SealevelCoreAdapter,
   TOKEN_COLLATERALIZED_STANDARDS,
-  TokenAmount,
+  type Token,
   type WarpTypedTransaction,
   type WarpCore,
   WarpTxCategory,
@@ -21,7 +19,8 @@ import {
   ProtocolType,
   assert,
   ensure0x,
-  isZeroishAddress,
+  fromWei,
+  isEVMLike,
 } from '@humanode-hyperlane/utils';
 
 import type { ExternalBridgeType } from '../config/types.js';
@@ -50,6 +49,11 @@ import {
 } from '../utils/tokenUtils.js';
 import { parseSolanaPrivateKey } from '../utils/solanaKeyParser.js';
 import { toProtocolTransaction } from '../utils/transactionUtils.js';
+import {
+  alignLocalToCanonical,
+  denormalizeToLocal,
+  normalizeToCanonical,
+} from '../utils/balanceUtils.js';
 
 /**
  * Buffer percentage to add when bridging inventory.
@@ -71,6 +75,86 @@ const GAS_COST_MULTIPLIER = 20n;
  */
 const MAX_GAS_PERCENT_THRESHOLD = 10n;
 
+type BridgeCapacity = {
+  maxSourceInput: bigint;
+  maxTargetOutput: bigint;
+};
+
+type BridgeQuoteMode = 'forward' | 'reverse';
+
+type InventoryMovementExecutionResult =
+  | {
+      success: true;
+      txHash: string;
+      inputRequired: bigint;
+      quotedOutput: bigint;
+      quotedOutputMin: bigint;
+      quoteModeUsed: BridgeQuoteMode;
+    }
+  | {
+      success: false;
+      error: string;
+    };
+const RECOVERABLE_MAX_TRANSFER_ERROR_MESSAGES = [
+  'balance may be insufficient',
+  'transfer amount exceeds balance',
+  'insufficient balance',
+];
+
+function hasRecoverableMaxTransferErrorMessage(message: string): boolean {
+  const normalized = message.toLowerCase();
+  return (
+    normalized.includes('unpredictable_gas_limit') ||
+    RECOVERABLE_MAX_TRANSFER_ERROR_MESSAGES.some((pattern) =>
+      normalized.includes(pattern),
+    )
+  );
+}
+
+function isRecoverableMaxTransferProbeError(error: unknown): boolean {
+  const seen = new Set<unknown>();
+  const stack: unknown[] = [error];
+
+  while (stack.length > 0) {
+    const current = stack.pop();
+    if (current == null) continue;
+
+    if (typeof current === 'string') {
+      if (hasRecoverableMaxTransferErrorMessage(current)) return true;
+      continue;
+    }
+
+    if (typeof current !== 'object') continue;
+    if (seen.has(current)) continue;
+    seen.add(current);
+
+    const candidate = current as {
+      code?: unknown;
+      message?: unknown;
+      cause?: unknown;
+      error?: unknown;
+    };
+
+    if (
+      typeof candidate.code === 'string' &&
+      candidate.code.toUpperCase() === 'UNPREDICTABLE_GAS_LIMIT'
+    ) {
+      return true;
+    }
+
+    if (
+      typeof candidate.message === 'string' &&
+      hasRecoverableMaxTransferErrorMessage(candidate.message)
+    ) {
+      return true;
+    }
+
+    stack.push(candidate.cause, candidate.error);
+  }
+
+  return false;
+}
+
 /**
  * Configuration for the InventoryRebalancer.
  */
@@ -287,6 +371,10 @@ export class InventoryRebalancer implements IInventoryRebalancer {
     return total;
   }
 
+  private formatLocalAmount(amount: bigint, token: Token): string {
+    return fromWei(amount.toString(), token.decimals);
+  }
+
   /**
    * Get the effective available inventory for a chain, accounting for
    * inventory already consumed during this execution cycle.
@@ -532,12 +620,18 @@ export class InventoryRebalancer implements IInventoryRebalancer {
       {
         strategyRoute: `${origin} (surplus) → ${destination} (deficit)`,
         executionRoute: `transferRemote FROM ${destination} TO ${origin}`,
-        amount: amount.toString(),
+        canonicalAmount: amount.toString(),
         intentId: intent.id,
       },
       'Executing inventory route',
     );
 
+    const sourceToken = this.getTokenForChain(destination);
+    assert(sourceToken, `No token found for source chain: ${destination}`);
+    const requestedLocalAmount = denormalizeToLocal(amount, sourceToken);
+    const executionSender = this.getInventorySignerAddress(destination);
+    const executionRecipient = this.getInventorySignerAddress(origin);
+
     // Check available inventory on the DESTINATION (deficit) chain
     // We need inventory here because transferRemote is called FROM this chain
     const availableInventory = this.getEffectiveAvailableInventory(destination);
@@ -546,9 +640,15 @@ export class InventoryRebalancer implements IInventoryRebalancer {
       {
         checkingChain: destination,
         availableInventory: availableInventory.toString(),
-        availableInventoryEth: (Number(availableInventory) / 1e18).toFixed(6),
-        requiredAmount: amount.toString(),
-        requiredAmountEth: (Number(amount) / 1e18).toFixed(6),
+        availableInventoryFormatted: this.formatLocalAmount(
+          availableInventory,
+          sourceToken,
+        ),
+        requiredAmount: requestedLocalAmount.toString(),
+        requiredAmountFormatted: this.formatLocalAmount(
+          requestedLocalAmount,
+          sourceToken,
+        ),
       },
       'Checking effective inventory on destination (deficit) chain',
     );
@@ -559,15 +659,72 @@ export class InventoryRebalancer implements IInventoryRebalancer {
       destination, // FROM chain (where transferRemote is called)
       origin, // TO chain (where Hyperlane message goes)
       availableInventory,
-      amount,
+      requestedLocalAmount,
       this.multiProvider,
       this.warpCore.multiProvider,
       this.getTokenForChain.bind(this),
-      this.getInventorySignerAddress(destination),
+      executionSender,
       isNativeTokenStandard,
       this.logger,
     );
-    const { maxTransferable, minViableTransfer } = costs;
+    const { minViableTransfer } = costs;
+    let maxTransferable = costs.maxTransferable;
+
+    if (!isNativeTokenStandard(sourceToken.standard)) {
+      if (availableInventory === 0n) {
+        maxTransferable = 0n;
+        this.logger.debug(
+          {
+            fromChain: destination,
+            toChain: origin,
+            requestedAmount: requestedLocalAmount.toString(),
+          },
+          'Skipping fee-aware max transferable probe because destination inventory is zero',
+        );
+      } else {
+        try {
+          const feeAwareMaxTransfer = await this.warpCore.getMaxTransferAmount({
+            balance: sourceToken.amount(availableInventory),
+            destination: origin,
+            sender: executionSender,
+            recipient: executionRecipient,
+          });
+
+          maxTransferable =
+            feeAwareMaxTransfer.amount < requestedLocalAmount
+              ? feeAwareMaxTransfer.amount
+              : requestedLocalAmount;
+
+          this.logger.debug(
+            {
+              fromChain: destination,
+              toChain: origin,
+              availableInventory: availableInventory.toString(),
+              requestedAmount: requestedLocalAmount.toString(),
+              feeAwareMaxTransferable: maxTransferable.toString(),
+            },
+            'Calculated fee-aware max transferable amount for non-native route',
+          );
+        } catch (error) {
+          if (!isRecoverableMaxTransferProbeError(error)) {
+            throw error;
+          }
+
+          maxTransferable = 0n;
+          this.logger.warn(
+            {
+              fromChain: destination,
+              toChain: origin,
+              availableInventory: availableInventory.toString(),
+              requestedAmount: requestedLocalAmount.toString(),
+              error: error instanceof Error ? error.message : String(error),
+              intentId: intent.id,
+            },
+            'Fee-aware max transferable probe failed due to insufficient balance, falling back to external bridge',
+          );
+        }
+      }
+    }
 
     // Calculate total inventory across all chains
     // Note: consumedInventory tracking is handled separately within this cycle
@@ -577,24 +734,36 @@ export class InventoryRebalancer implements IInventoryRebalancer {
       {
         fromChain: destination,
         toChain: origin,
-        availableInventoryEth: (Number(availableInventory) / 1e18).toFixed(6),
-        requestedAmountEth: (Number(amount) / 1e18).toFixed(6),
-        maxTransferableEth: (Number(maxTransferable) / 1e18).toFixed(6),
-        minViableTransferEth: (Number(minViableTransfer) / 1e18).toFixed(6),
-        totalInventoryEth: (Number(totalInventory) / 1e18).toFixed(6),
-        canFullyFulfill: maxTransferable >= amount,
+        availableInventoryFormatted: this.formatLocalAmount(
+          availableInventory,
+          sourceToken,
+        ),
+        requestedAmountFormatted: this.formatLocalAmount(
+          requestedLocalAmount,
+          sourceToken,
+        ),
+        maxTransferableFormatted: this.formatLocalAmount(
+          maxTransferable,
+          sourceToken,
+        ),
+        minViableTransferFormatted: this.formatLocalAmount(
+          minViableTransfer,
+          sourceToken,
+        ),
+        canFullyFulfill: maxTransferable >= requestedLocalAmount,
         canPartialFulfill: maxTransferable >= minViableTransfer,
+        totalInventory: totalInventory.toString(),
       },
       'Calculated max transferable amount with cost-based threshold',
     );
 
     // Early exit: If remaining amount is below minViableTransfer, complete the intent
     // This prevents infinite loops when the remaining amount is too small to economically bridge
-    if (amount < minViableTransfer) {
+    if (requestedLocalAmount < minViableTransfer) {
       this.logger.info(
         {
           intentId: intent.id,
-          amount: amount.toString(),
+          amount: requestedLocalAmount.toString(),
           minViableTransfer: minViableTransfer.toString(),
         },
         'Remaining amount below minViableTransfer, completing intent with acceptable loss',
@@ -615,227 +784,291 @@ export class InventoryRebalancer implements IInventoryRebalancer {
       ...route,
       origin: destination, // transferRemote called FROM here
       destination: origin, // Hyperlane message goes TO here
+      amount: requestedLocalAmount,
     };
 
-    if (maxTransferable >= amount) {
+    if (maxTransferable >= requestedLocalAmount) {
       // Sufficient inventory on destination - execute transferRemote directly
+      const fulfilledCanonicalAmount = normalizeToCanonical(
+        requestedLocalAmount,
+        sourceToken,
+      );
       const result = await this.executeTransferRemote(
         swappedRoute,
         intent,
-        costs.gasQuote!,
+        fulfilledCanonicalAmount,
       );
       // Return original strategy route in result (not the swapped execution route)
       return { ...result, route };
     } else if (maxTransferable > 0n && maxTransferable >= minViableTransfer) {
       // Partial transfer: Transfer available inventory when economically viable
-      const partialSwappedRoute: InventoryRoute = {
-        ...swappedRoute,
-        amount: maxTransferable,
-      };
-      const result = await this.executeTransferRemote(
-        partialSwappedRoute,
-        intent,
-        costs.gasQuote!,
-      );
-
-      this.logger.info(
-        {
-          intentId: intent.id,
-          partialAmount: maxTransferable.toString(),
-          requestedAmount: amount.toString(),
-          remainingAmount: (amount - maxTransferable).toString(),
-        },
-        'Executed partial inventory deposit, remaining will be handled in future cycles',
+      const alignedExecution = alignLocalToCanonical(
+        maxTransferable,
+        sourceToken,
       );
-
-      // Return original strategy route in result (not the swapped execution route)
-      return { ...result, route };
-    } else {
-      // Inventory below cost-based threshold - trigger ExternalBridge movement TO destination chain
-      this.logger.info(
-        {
-          targetChain: destination,
-          maxTransferable: maxTransferable.toString(),
-          minViableTransfer: minViableTransfer.toString(),
-          costMultiplier: MIN_VIABLE_COST_MULTIPLIER.toString(),
-          intentId: intent.id,
-        },
-        'Inventory below cost-based threshold on destination, triggering LiFi movement',
-      );
-
-      // Get all available source chains with raw inventory
-      const allSources = this.selectAllSourceChains(destination);
-
-      if (allSources.length === 0) {
-        this.logger.warn(
+      if (alignedExecution.messageAmount === 0n) {
+        this.logger.info(
           {
-            origin,
-            destination,
-            amount: amount.toString(),
             intentId: intent.id,
+            maxTransferable: maxTransferable.toString(),
           },
-          'No inventory available on any monitored chain',
+          'Skipping partial transferRemote because available local amount cannot produce canonical progress',
         );
-
-        return {
-          route,
-          success: false,
-          error: 'No inventory available on any monitored chain',
+      } else {
+        const partialSwappedRoute: InventoryRoute = {
+          ...swappedRoute,
+          amount: alignedExecution.localAmount,
         };
-      }
-
-      // NEW: Calculate max viable amount for each source chain
-      // This uses the quote API to determine gas costs upfront
-      const viableSources: Array<{ chain: ChainName; maxViable: bigint }> = [];
-
-      for (const source of allSources) {
-        const maxViable = await this.calculateMaxViableBridgeAmount(
-          source.chain,
-          destination,
-          source.availableAmount,
-          route.externalBridge,
+        const result = await this.executeTransferRemote(
+          partialSwappedRoute,
+          intent,
+          alignedExecution.messageAmount,
         );
 
-        if (maxViable > 0n) {
-          viableSources.push({ chain: source.chain, maxViable });
-        }
-      }
-
-      // Sort by max viable descending (bridge from largest sources first)
-      viableSources.sort((a, b) => (a.maxViable > b.maxViable ? -1 : 1));
-
-      if (viableSources.length === 0) {
-        this.logger.warn(
+        this.logger.info(
           {
-            targetChain: destination,
-            sourcesChecked: allSources.length,
             intentId: intent.id,
+            partialAmount: alignedExecution.localAmount.toString(),
+            partialAmountCanonical: alignedExecution.messageAmount.toString(),
+            requestedAmount: requestedLocalAmount.toString(),
+            requestedAmountCanonical: amount.toString(),
+            remainingAmountCanonical: (amount > alignedExecution.messageAmount
+              ? amount - alignedExecution.messageAmount
+              : 0n
+            ).toString(),
           },
-          'No viable bridge sources - all chains have insufficient inventory or high gas costs',
+          'Executed partial inventory deposit, remaining will be handled in future cycles',
         );
 
-        return {
-          route,
-          success: false,
-          error: 'No viable bridge sources available',
-        };
+        // Return original strategy route in result (not the swapped execution route)
+        return { ...result, route };
       }
+    }
+
+    // Inventory below cost-based threshold - trigger ExternalBridge movement TO destination chain
+    this.logger.info(
+      {
+        targetChain: destination,
+        maxTransferable: maxTransferable.toString(),
+        minViableTransfer: minViableTransfer.toString(),
+        costMultiplier: MIN_VIABLE_COST_MULTIPLIER.toString(),
+        intentId: intent.id,
+      },
+      'Inventory below cost-based threshold on destination, triggering LiFi movement',
+    );
+
+    // Get all available source chains with raw inventory
+    const allSources = this.selectAllSourceChains(destination);
+
+    if (allSources.length === 0) {
+      this.logger.warn(
+        {
+          origin,
+          destination,
+          amount: requestedLocalAmount.toString(),
+          intentId: intent.id,
+        },
+        'No inventory available on any monitored chain',
+      );
 
-      // Create bridge plans using VIABLE amounts (gas already accounted for)
-      const targetWithBuffer =
-        ((amount + costs.totalCost) * (100n + BRIDGE_BUFFER_PERCENT)) / 100n;
-      const bridgePlans: Array<{ chain: ChainName; amount: bigint }> = [];
-      let totalPlanned = 0n;
+      return {
+        route,
+        success: false,
+        error: 'No inventory available on any monitored chain',
+      };
+    }
 
-      for (const source of viableSources) {
-        if (totalPlanned >= targetWithBuffer) break;
+    // Calculate source capacities in destination-local units.
+    const viableSources: Array<{
+      chain: ChainName;
+      maxSourceInput: bigint;
+      maxTargetOutput: bigint;
+    }> = [];
 
-        const remaining = targetWithBuffer - totalPlanned;
-        const amountFromSource =
-          source.maxViable >= remaining ? remaining : source.maxViable; // Already gas-adjusted!
+    for (const source of allSources) {
+      const capacity = await this.calculateBridgeCapacity(
+        source.chain,
+        destination,
+        source.availableAmount,
+        route.externalBridge,
+      );
 
-        bridgePlans.push({
-          chain: source.chain,
-          amount: amountFromSource,
-        });
-        totalPlanned += amountFromSource;
+      if (capacity.maxTargetOutput > 0n) {
+        viableSources.push({ chain: source.chain, ...capacity });
       }
+    }
 
-      this.logger.info(
+    // Sort by destination output descending.
+    viableSources.sort((a, b) =>
+      a.maxTargetOutput > b.maxTargetOutput ? -1 : 1,
+    );
+
+    if (viableSources.length === 0) {
+      this.logger.warn(
         {
           targetChain: destination,
-          viableSources: viableSources.map((s) => ({
-            chain: s.chain,
-            maxViable: s.maxViable.toString(),
-            maxViableEth: (Number(s.maxViable) / 1e18).toFixed(6),
-          })),
-          bridgePlans: bridgePlans.map((p) => ({
-            chain: p.chain,
-            amount: p.amount.toString(),
-            amountEth: (Number(p.amount) / 1e18).toFixed(6),
-          })),
-          totalPlanned: totalPlanned.toString(),
-          targetWithBuffer: targetWithBuffer.toString(),
+          sourcesChecked: allSources.length,
           intentId: intent.id,
         },
-        'Created bridge plans using gas-adjusted viable amounts',
+        'No viable bridge sources - all chains have insufficient inventory or high gas costs',
       );
 
-      // Execute all bridges in parallel
-      const bridgeResults = await Promise.allSettled(
-        bridgePlans.map((plan) =>
-          this.executeInventoryMovement(
-            plan.chain,
-            destination,
-            plan.amount,
-            intent,
-            route.externalBridge,
-          ),
+      return {
+        route,
+        success: false,
+        error: 'No viable bridge sources available',
+      };
+    }
+
+    // Create bridge plans using destination-local output amounts.
+    const shortfall =
+      requestedLocalAmount > availableInventory
+        ? requestedLocalAmount - availableInventory
+        : 0n;
+    const targetWithBuffer =
+      ((shortfall + costs.totalCost) * (100n + BRIDGE_BUFFER_PERCENT)) / 100n;
+    const bridgePlans: Array<{
+      chain: ChainName;
+      maxSourceInput: bigint;
+      targetOutput: bigint;
+      quoteMode: BridgeQuoteMode;
+    }> = [];
+    let totalPlanned = 0n;
+
+    for (const source of viableSources) {
+      if (totalPlanned >= targetWithBuffer) break;
+
+      const remaining = targetWithBuffer - totalPlanned;
+      const targetOutput =
+        source.maxTargetOutput >= remaining
+          ? remaining
+          : source.maxTargetOutput;
+      const quoteMode: BridgeQuoteMode =
+        source.maxTargetOutput > remaining ? 'reverse' : 'forward';
+
+      bridgePlans.push({
+        chain: source.chain,
+        maxSourceInput: source.maxSourceInput,
+        targetOutput,
+        quoteMode,
+      });
+      totalPlanned += targetOutput;
+    }
+
+    this.logger.info(
+      {
+        targetChain: destination,
+        viableSources: viableSources.map((s) => ({
+          chain: s.chain,
+          maxSourceInput: s.maxSourceInput.toString(),
+          maxTargetOutput: s.maxTargetOutput.toString(),
+        })),
+        bridgePlans: bridgePlans.map((p) => ({
+          chain: p.chain,
+          maxSourceInput: p.maxSourceInput.toString(),
+          targetOutput: p.targetOutput.toString(),
+          quoteMode: p.quoteMode,
+        })),
+        totalPlanned: totalPlanned.toString(),
+        shortfall: shortfall.toString(),
+        targetWithBuffer: targetWithBuffer.toString(),
+        intentId: intent.id,
+      },
+      'Created bridge plans using gas-adjusted viable amounts',
+    );
+
+    // Execute all bridges in parallel
+    const bridgeResults = await Promise.allSettled(
+      bridgePlans.map((plan) =>
+        this.executeInventoryMovement(
+          plan.chain,
+          destination,
+          plan.targetOutput,
+          plan.maxSourceInput,
+          plan.quoteMode,
+          intent,
+          route.externalBridge,
         ),
-      );
+      ),
+    );
 
-      // Process results
-      let successCount = 0;
-      let totalBridged = 0n;
-      const failedErrors: string[] = [];
+    // Process results
+    let successCount = 0;
+    let totalQuotedOutputMin = 0n;
+    const failedErrors: string[] = [];
 
-      for (let i = 0; i < bridgeResults.length; i++) {
-        const result = bridgeResults[i];
-        const plan = bridgePlans[i];
+    for (let i = 0; i < bridgeResults.length; i++) {
+      const result = bridgeResults[i];
+      const plan = bridgePlans[i];
 
-        if (result.status === 'fulfilled' && result.value.success) {
-          successCount++;
-          totalBridged += plan.amount;
-          this.logger.info(
-            {
-              sourceChain: plan.chain,
-              amount: plan.amount.toString(),
-              txHash: result.value.txHash,
-            },
-            'Inventory movement succeeded',
-          );
-        } else {
-          const error =
-            result.status === 'rejected'
-              ? result.reason?.message
-              : result.value.error;
-          if (error) {
-            failedErrors.push(`${plan.chain}: ${error}`);
+      if (result.status === 'fulfilled' && result.value.success) {
+        successCount++;
+        totalQuotedOutputMin += result.value.quotedOutputMin;
+        this.logger.info(
+          {
+            sourceChain: plan.chain,
+            plannedTargetOutput: plan.targetOutput.toString(),
+            quotedOutput: result.value.quotedOutput.toString(),
+            quotedOutputMin: result.value.quotedOutputMin.toString(),
+            quoteModeUsed: result.value.quoteModeUsed,
+            txHash: result.value.txHash,
+          },
+          'Inventory movement succeeded',
+        );
+      } else {
+        let error: string | undefined;
+        if (result.status === 'rejected') {
+          if (result.reason instanceof Error) {
+            error = result.reason.message;
+          } else if (typeof result.reason === 'string') {
+            error = result.reason;
+          } else {
+            try {
+              error = JSON.stringify(result.reason) ?? String(result.reason);
+            } catch {
+              error = String(result.reason);
+            }
           }
-          this.logger.warn(
-            {
-              sourceChain: plan.chain,
-              amount: plan.amount.toString(),
-              error,
-            },
-            'Inventory movement failed',
-          );
+        } else if (!result.value.success) {
+          error = result.value.error;
         }
+        if (error) {
+          failedErrors.push(`${plan.chain}: ${error}`);
+        }
+        this.logger.warn(
+          {
+            sourceChain: plan.chain,
+            plannedTargetOutput: plan.targetOutput.toString(),
+            error,
+          },
+          'Inventory movement failed',
+        );
       }
+    }
 
-      if (successCount === 0) {
-        const errorDetails =
-          failedErrors.length > 0 ? ` (${failedErrors.join('; ')})` : '';
-        return {
-          route,
-          success: false,
-          error: `All inventory movements failed${errorDetails}`,
-        };
-      }
+    if (successCount === 0) {
+      const errorDetails =
+        failedErrors.length > 0 ? ` (${failedErrors.join('; ')})` : '';
+      return {
+        route,
+        success: false,
+        error: `All inventory movements failed${errorDetails}`,
+      };
+    }
 
-      this.logger.info(
-        {
-          targetChain: destination,
-          successCount,
-          totalBridged: totalBridged.toString(),
-          targetAmount: amount.toString(),
-          intentId: intent.id,
-        },
-        'Parallel inventory movements completed, transferRemote will execute after bridges complete',
-      );
+    this.logger.info(
+      {
+        targetChain: destination,
+        successCount,
+        totalQuotedOutputMin: totalQuotedOutputMin.toString(),
+        targetAmount: requestedLocalAmount.toString(),
+        targetAmountCanonical: amount.toString(),
+        intentId: intent.id,
+      },
+      'Parallel inventory movements completed, transferRemote will execute after bridges complete',
+    );
 
-      return { route, success: true };
-    }
+    return { route, success: true };
   }
 
   /**
@@ -851,12 +1084,11 @@ export class InventoryRebalancer implements IInventoryRebalancer {
    *
    * @param route - The transfer route (swapped direction)
    * @param intent - The rebalance intent being executed
-   * @param gasQuote - Pre-calculated gas quote from calculateTransferCosts
    */
   private async executeTransferRemote(
     route: InventoryRoute,
     intent: RebalanceIntent,
-    gasQuote: InterchainGasQuote,
+    fulfilledCanonicalAmount: bigint,
   ): Promise<InventoryExecutionResult> {
     const { origin, destination, amount } = route;
 
@@ -868,46 +1100,16 @@ export class InventoryRebalancer implements IInventoryRebalancer {
     const destinationDomain = this.multiProvider.getDomainId(destination);
 
     this.logger.debug(
-      {
-        origin,
-        destination,
-        amount: amount.toString(),
-        gasQuote: {
-          igpQuote: gasQuote.igpQuote.amount.toString(),
-          tokenFeeQuote: gasQuote.tokenFeeQuote?.amount?.toString() ?? 'none',
-        },
-      },
-      'Using pre-calculated gas quote for transferRemote',
+      { origin, destination, amount: amount.toString() },
+      'Building transferRemote transactions for exact execution amount',
     );
 
-    // Convert pre-calculated gas quote to TokenAmount for WarpCore
-    const originChainMetadata = this.multiProvider.getChainMetadata(origin);
-    const igpAddressOrDenom = gasQuote.igpQuote.addressOrDenom;
-    const igpToken =
-      !igpAddressOrDenom || isZeroishAddress(igpAddressOrDenom)
-        ? Token.FromChainMetadataNativeToken(originChainMetadata)
-        : this.warpCore.findToken(origin, igpAddressOrDenom);
-    assert(igpToken, `IGP fee token ${igpAddressOrDenom} is unknown`);
-    const interchainFee = new TokenAmount(gasQuote.igpQuote.amount, igpToken);
-
-    let tokenFeeQuote: TokenAmount | undefined;
-    if (gasQuote.tokenFeeQuote?.amount) {
-      const feeAddress = gasQuote.tokenFeeQuote.addressOrDenom;
-      const feeToken =
-        !feeAddress || isZeroishAddress(feeAddress)
-          ? Token.FromChainMetadataNativeToken(originChainMetadata)
-          : originToken;
-      tokenFeeQuote = new TokenAmount(gasQuote.tokenFeeQuote.amount, feeToken);
-    }
-
     const originTokenAmount = originToken.amount(amount);
     const transferTxs = await this.warpCore.getTransferRemoteTxs({
       originTokenAmount,
       destination,
       sender: this.getInventorySignerAddress(origin),
       recipient: this.getInventorySignerAddress(destination),
-      interchainFee,
-      tokenFeeQuote,
     });
     assert(
       transferTxs.length > 0,
@@ -967,7 +1169,7 @@ export class InventoryRebalancer implements IInventoryRebalancer {
       intentId: intent.id,
       origin: this.multiProvider.getDomainId(origin),
       destination: destinationDomain,
-      amount,
+      amount: fulfilledCanonicalAmount,
       type: 'inventory_deposit',
       txHash: transferTxHash,
       messageId,
@@ -1024,6 +1226,7 @@ export class InventoryRebalancer implements IInventoryRebalancer {
   ): MultiProtocolSignerSignerAccountInfo {
     void chain;
     switch (protocol) {
+      case ProtocolType.Tron:
       case ProtocolType.Ethereum:
         return { protocol, privateKey: ensure0x(key) };
       case ProtocolType.Sealevel:
@@ -1063,7 +1266,7 @@ export class InventoryRebalancer implements IInventoryRebalancer {
     try {
       const protocol = this.getProtocolForChain(origin);
 
-      if (protocol === ProtocolType.Ethereum) {
+      if (isEVMLike(protocol)) {
         const provider =
           this.warpCore.multiProvider.getEthersV5Provider(origin);
         const receipt = await provider.getTransactionReceipt(txHash);
@@ -1076,7 +1279,9 @@ export class InventoryRebalancer implements IInventoryRebalancer {
           this.warpCore.multiProvider.getSolanaWeb3Provider(origin);
         const receipt = await provider.getTransaction(txHash, {
           commitment: 'confirmed',
-          maxSupportedTransactionVersion: 0,
+          maxSupportedTransactionVersion:
+            this.warpCore.multiProvider.getChainMetadata(origin)
+              .maxSupportedTransactionVersion ?? 0,
         });
         if (!receipt) return undefined;
         return { type: ProviderType.SolanaWeb3, receipt };
@@ -1122,40 +1327,30 @@ export class InventoryRebalancer implements IInventoryRebalancer {
   }
 
   /**
-   * Calculate the maximum amount that can be bridged from a source chain.
-   * Uses LiFi quote to determine gas costs, applies 20x multiplier buffer.
-   * Returns 0 if gas exceeds 10% of inventory (not economically viable).
-   *
-   * This is the key method for the gas-aware planning approach:
-   * - Gets a quote for the full raw inventory to determine actual gas costs
-   * - Applies conservative 20x buffer (LiFi underestimates by ~14x historically)
-   * - Returns 0 if gas > 10% of inventory (not worth bridging)
-   * - Returns inventory - estimatedGas if viable
+   * Calculate the bridge capacity from a source chain in destination-local units.
+   * Uses LiFi quotes to conservatively estimate the destination output available
+   * from the source chain's current local inventory.
    *
-   * @param sourceChain - Chain to bridge from
-   * @param targetChain - Chain to bridge to
-   * @param rawInventory - Raw available inventory on source chain
-   * @param externalBridgeType - External bridge type to use
-   * @returns Maximum viable bridge amount (0 if not viable)
+   * For native-token sources, gas is reserved from the source inventory and the
+   * output capacity is re-quoted from the remaining source input.
    */
-  private async calculateMaxViableBridgeAmount(
+  private async calculateBridgeCapacity(
     sourceChain: ChainName,
     targetChain: ChainName,
     rawInventory: bigint,
     externalBridgeType: ExternalBridgeType,
-  ): Promise<bigint> {
+  ): Promise<BridgeCapacity> {
     const sourceToken = this.getTokenForChain(sourceChain);
     const targetToken = this.getTokenForChain(targetChain);
-
-    if (!sourceToken || !targetToken) return 0n;
-
-    // Only applies to native tokens (need gas from same balance)
-    if (!isNativeTokenStandard(sourceToken.standard)) {
-      return rawInventory; // ERC20s don't compete with gas
-    }
+    assert(sourceToken, `No token found for source chain: ${sourceChain}`);
+    assert(targetToken, `No token found for target chain: ${targetChain}`);
 
     // Convert HypNative token addresses to the external bridge's native token representation
-    const fromTokenAddress = this.getNativeTokenAddress(externalBridgeType);
+    const fromTokenAddress = getExternalBridgeTokenAddress(
+      sourceToken,
+      externalBridgeType,
+      this.getNativeTokenAddress.bind(this),
+    );
     const toTokenAddress = getExternalBridgeTokenAddress(
       targetToken,
       externalBridgeType,
@@ -1167,7 +1362,7 @@ export class InventoryRebalancer implements IInventoryRebalancer {
 
     try {
       const externalBridge = this.getExternalBridge(externalBridgeType);
-      const quote = await externalBridge.quote({
+      const initialQuote = await externalBridge.quote({
         fromChain: sourceChainId,
         toChain: targetChainId,
         fromToken: fromTokenAddress,
@@ -1177,48 +1372,58 @@ export class InventoryRebalancer implements IInventoryRebalancer {
         toAddress: this.getInventorySignerAddress(targetChain),
       });
 
-      // Apply 20x multiplier on quoted gas (LiFi underestimates by ~14x)
-      const estimatedGas = quote.gasCosts * GAS_COST_MULTIPLIER;
+      let maxSourceInput = rawInventory;
+      let outputQuote = initialQuote;
 
-      // Viability check: gas should not exceed 10% of inventory
-      const maxGasThreshold = rawInventory / MAX_GAS_PERCENT_THRESHOLD;
-      if (estimatedGas > maxGasThreshold) {
-        this.logger.info(
-          {
-            sourceChain,
-            targetChain,
-            rawInventory: rawInventory.toString(),
-            rawInventoryEth: (Number(rawInventory) / 1e18).toFixed(6),
-            quotedGas: quote.gasCosts.toString(),
-            estimatedGas: estimatedGas.toString(),
-            estimatedGasEth: (Number(estimatedGas) / 1e18).toFixed(6),
-            maxGasThreshold: maxGasThreshold.toString(),
-            gasPercent: `${(Number(estimatedGas) * 100) / Number(rawInventory)}%`,
-          },
-          'Bridge not viable - gas cost exceeds 10% of inventory',
-        );
-        return 0n;
-      }
+      if (isNativeTokenStandard(sourceToken.standard)) {
+        const estimatedGas = initialQuote.gasCosts * GAS_COST_MULTIPLIER;
+        const maxGasThreshold = rawInventory / MAX_GAS_PERCENT_THRESHOLD;
+        if (estimatedGas > maxGasThreshold) {
+          this.logger.info(
+            {
+              sourceChain,
+              targetChain,
+              rawInventory: rawInventory.toString(),
+              quotedGas: initialQuote.gasCosts.toString(),
+              estimatedGas: estimatedGas.toString(),
+              maxGasThreshold: maxGasThreshold.toString(),
+            },
+            'Bridge not viable - gas cost exceeds 10% of inventory',
+          );
+          return { maxSourceInput: 0n, maxTargetOutput: 0n };
+        }
+
+        maxSourceInput = rawInventory - estimatedGas;
+        if (maxSourceInput <= 0n) {
+          return { maxSourceInput: 0n, maxTargetOutput: 0n };
+        }
 
-      // Max viable = inventory minus estimated gas
-      const maxViable = rawInventory - estimatedGas;
+        outputQuote = await externalBridge.quote({
+          fromChain: sourceChainId,
+          toChain: targetChainId,
+          fromToken: fromTokenAddress,
+          toToken: toTokenAddress,
+          fromAmount: maxSourceInput,
+          fromAddress: this.getInventorySignerAddress(sourceChain),
+          toAddress: this.getInventorySignerAddress(targetChain),
+        });
+      }
 
       this.logger.info(
         {
           sourceChain,
           targetChain,
           rawInventory: rawInventory.toString(),
-          rawInventoryEth: (Number(rawInventory) / 1e18).toFixed(6),
-          quotedGas: quote.gasCosts.toString(),
-          estimatedGas: estimatedGas.toString(),
-          estimatedGasEth: (Number(estimatedGas) / 1e18).toFixed(6),
-          maxViable: maxViable.toString(),
-          maxViableEth: (Number(maxViable) / 1e18).toFixed(6),
+          maxSourceInput: maxSourceInput.toString(),
+          maxTargetOutput: outputQuote.toAmountMin.toString(),
         },
-        'Calculated max viable bridge amount',
+        'Calculated bridge capacity',
       );
 
-      return maxViable;
+      return {
+        maxSourceInput,
+        maxTargetOutput: outputQuote.toAmountMin,
+      };
     } catch (error) {
       this.logger.warn(
         {
@@ -1226,21 +1431,24 @@ export class InventoryRebalancer implements IInventoryRebalancer {
           targetChain,
           error: (error as Error).message,
         },
-        'Failed to calculate max viable bridge amount, skipping chain',
+        'Failed to calculate bridge capacity, skipping chain',
       );
-      return 0n;
+      return { maxSourceInput: 0n, maxTargetOutput: 0n };
     }
   }
 
   /**
    * Execute inventory movement from source chain to target chain via LiFi bridge.
    *
-   * IMPORTANT: The amount parameter is now the MAX VIABLE amount (gas already subtracted
-   * by calculateMaxViableBridgeAmount). This method trusts that the amount is pre-validated.
+   * Quote mode is chosen during planning:
+   * - `reverse`: request an exact target-chain output when the source has headroom
+   * - `forward`: spend the source cap directly when source inventory is the limiter
    *
    * @param sourceChain - Chain to move inventory from
    * @param targetChain - Chain to move inventory to (origin chain for rebalancing)
-   * @param amount - Pre-validated amount to bridge (gas already accounted for)
+   * @param targetOutputAmount - Destination-local amount to receive
+   * @param maxSourceInput - Maximum source-local amount available for this plan
+   * @param quoteMode - Whether to execute this bridge plan as exact-input or exact-output
    * @param intent - Rebalance intent for tracking
    * @param externalBridgeType - External bridge type to use
    * @returns Result with success status and optional txHash/error
@@ -1248,10 +1456,12 @@ export class InventoryRebalancer implements IInventoryRebalancer {
   private async executeInventoryMovement(
     sourceChain: ChainName,
     targetChain: ChainName,
-    amount: bigint,
+    targetOutputAmount: bigint,
+    maxSourceInput: bigint,
+    quoteMode: BridgeQuoteMode,
     intent: RebalanceIntent,
     externalBridgeType: ExternalBridgeType,
-  ): Promise<{ success: boolean; txHash?: string; error?: string }> {
+  ): Promise<InventoryMovementExecutionResult> {
     const sourceToken = this.getTokenForChain(sourceChain);
     if (!sourceToken) {
       return {
@@ -1297,57 +1507,53 @@ export class InventoryRebalancer implements IInventoryRebalancer {
       'Resolved token addresses for LiFi bridge',
     );
 
-    // Calculate minViableTransfer for the target chain
-    // If bridging less than this, the received amount won't be enough to execute transferRemote
-    // So we over-bridge to ensure we can complete the intent in the next cycle
-    const costs = await calculateTransferCosts(
-      targetChain, // FROM chain for transferRemote (the target of this bridge)
-      sourceChain, // TO chain for transferRemote (Hyperlane message destination)
-      amount, // availableInventory (not used for minViableTransfer calculation)
-      amount, // requestedAmount
-      this.multiProvider,
-      this.warpCore.multiProvider,
-      this.getTokenForChain.bind(this),
-      this.getInventorySignerAddress(targetChain),
-      isNativeTokenStandard,
-      this.logger,
-    );
-    const { minViableTransfer } = costs;
+    try {
+      const externalBridge = this.getExternalBridge(externalBridgeType);
+      const fromAddress = this.getInventorySignerAddress(sourceChain);
+      const toAddress = this.getInventorySignerAddress(targetChain);
+      const quoteWithMode = async (mode: BridgeQuoteMode) =>
+        externalBridge.quote({
+          fromChain: sourceChainId,
+          toChain: targetChainId,
+          fromToken: fromTokenAddress,
+          toToken: toTokenAddress,
+          ...(mode === 'forward'
+            ? { fromAmount: maxSourceInput }
+            : { toAmount: targetOutputAmount }),
+          fromAddress,
+          toAddress,
+        });
 
-    // If the requested amount is below minViableTransfer, adjust it up
-    // This ensures we bridge enough to actually complete the final transferRemote
-    const effectiveAmount =
-      amount < minViableTransfer ? minViableTransfer : amount;
+      let quoteModeUsed = quoteMode;
+      let quote = await quoteWithMode(quoteModeUsed);
 
-    if (effectiveAmount !== amount) {
-      this.logger.info(
-        {
-          originalAmount: amount.toString(),
-          effectiveAmount: effectiveAmount.toString(),
-          minViableTransfer: minViableTransfer.toString(),
-          originalAmountEth: (Number(amount) / 1e18).toFixed(6),
-          effectiveAmountEth: (Number(effectiveAmount) / 1e18).toFixed(6),
-          minViableTransferEth: (Number(minViableTransfer) / 1e18).toFixed(6),
-          adjustedUp: true,
-          intentId: intent.id,
-        },
-        'Over-bridging to minViableTransfer to ensure final transferRemote can complete',
-      );
-    }
+      if (quoteModeUsed === 'reverse' && quote.fromAmount > maxSourceInput) {
+        this.logger.warn(
+          {
+            sourceChain,
+            targetChain,
+            plannedQuoteMode: quoteMode,
+            requestedTargetOutput: targetOutputAmount.toString(),
+            quotedInput: quote.fromAmount.toString(),
+            maxSourceInput: maxSourceInput.toString(),
+            intentId: intent.id,
+          },
+          'Reverse bridge quote exceeded source capacity, retrying with forward quote',
+        );
 
-    try {
-      const externalBridge = this.getExternalBridge(externalBridgeType);
-      const quote = await externalBridge.quote({
-        fromChain: sourceChainId,
-        toChain: targetChainId,
-        fromToken: fromTokenAddress,
-        toToken: toTokenAddress,
-        fromAmount: effectiveAmount,
-        fromAddress: this.getInventorySignerAddress(sourceChain),
-        toAddress: this.getInventorySignerAddress(targetChain),
-      });
+        // Spend the full source cap on fallback; minor output drift is acceptable
+        // and will be reconciled by later cycles rather than risking livelock.
+        quoteModeUsed = 'forward';
+        quote = await quoteWithMode(quoteModeUsed);
+      }
 
       const inputRequired = quote.fromAmount;
+      if (inputRequired > maxSourceInput) {
+        return {
+          success: false,
+          error: `Bridge input ${inputRequired} exceeded planned source capacity ${maxSourceInput}`,
+        };
+      }
 
       this.logger.info(
         {
@@ -1355,19 +1561,35 @@ export class InventoryRebalancer implements IInventoryRebalancer {
           targetChain,
           sourceChainId,
           targetChainId,
-          preValidatedAmount: amount.toString(),
-          preValidatedAmountEth: (Number(amount) / 1e18).toFixed(6),
-          effectiveAmount: effectiveAmount.toString(),
-          effectiveAmountEth: (Number(effectiveAmount) / 1e18).toFixed(6),
+          requestedTargetOutput: targetOutputAmount.toString(),
+          requestedTargetOutputFormatted: this.formatLocalAmount(
+            targetOutputAmount,
+            targetToken,
+          ),
+          quoteModePlanned: quoteMode,
+          quoteModeUsed,
+          retriedAsForward:
+            quoteMode === 'reverse' && quoteModeUsed === 'forward',
           inputRequired: inputRequired.toString(),
-          expectedOutput: quote.toAmount.toString(),
-          expectedOutputEth: (Number(quote.toAmount) / 1e18).toFixed(6),
+          inputRequiredFormatted: this.formatLocalAmount(
+            inputRequired,
+            sourceToken,
+          ),
+          quotedOutput: quote.toAmount.toString(),
+          quotedOutputMin: quote.toAmountMin.toString(),
+          quotedOutputFormatted: this.formatLocalAmount(
+            quote.toAmount,
+            targetToken,
+          ),
+          quotedOutputMinFormatted: this.formatLocalAmount(
+            quote.toAmountMin,
+            targetToken,
+          ),
           gasCosts: quote.gasCosts.toString(),
           feeCosts: quote.feeCosts.toString(),
           intentId: intent.id,
-          adjustedForMinViable: effectiveAmount > amount,
         },
-        'Executing inventory movement via LiFi with pre-validated amount',
+        'Executing inventory movement via bridge quote',
       );
 
       this.logger.debug(
@@ -1410,6 +1632,8 @@ export class InventoryRebalancer implements IInventoryRebalancer {
         'Inventory movement transaction executed',
       );
 
+      // Keep bridge consumption in source-local units; intent fulfillment only
+      // advances from canonical inventory_deposit amounts after transferRemote.
       await this.actionTracker.createRebalanceAction({
         intentId: intent.id,
         origin: this.multiProvider.getDomainId(sourceChain),
@@ -1433,22 +1657,31 @@ export class InventoryRebalancer implements IInventoryRebalancer {
         'Updated consumed inventory after LiFi bridge',
       );
 
-      return { success: true, txHash: result.txHash };
+      return {
+        success: true,
+        txHash: result.txHash,
+        inputRequired,
+        quotedOutput: quote.toAmount,
+        quotedOutputMin: quote.toAmountMin,
+        quoteModeUsed,
+      };
     } catch (error) {
+      const errorMessage =
+        error instanceof Error ? error.message : String(error);
       this.logger.error(
         {
           sourceChain,
           targetChain,
-          amount: amount.toString(),
+          amount: targetOutputAmount.toString(),
           intentId: intent.id,
-          error: (error as Error).message,
+          error: errorMessage,
         },
         'Failed to execute inventory movement',
       );
 
       return {
         success: false,
-        error: (error as Error).message,
+        error: errorMessage,
       };
     }
   }