@humanode-hyperlane/rebalancer 27.2.2 → 1029.1.1

package/dist/core/InventoryRebalancer.js

@@ -1,9 +1,10 @@
-import { HyperlaneCore, Token, ProviderType, SealevelCoreAdapter, TOKEN_COLLATERALIZED_STANDARDS, TokenAmount, WarpTxCategory, getSignerForChain, } from '@humanode-hyperlane/sdk';
-import { ProtocolType, assert, ensure0x, isZeroishAddress, } from '@humanode-hyperlane/utils';
+import { HyperlaneCore, ProviderType, SealevelCoreAdapter, TOKEN_COLLATERALIZED_STANDARDS, WarpTxCategory, getSignerForChain, } from '@humanode-hyperlane/sdk';
+import { ProtocolType, assert, ensure0x, fromWei, isEVMLike, } from '@humanode-hyperlane/utils';
 import { MIN_VIABLE_COST_MULTIPLIER, calculateTransferCosts, } from '../utils/gasEstimation.js';
 import { getExternalBridgeTokenAddress, isNativeTokenStandard, } 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.
  * Bridges (amount * (100 + BRIDGE_BUFFER_PERCENT)) / 100 to account for slippage.
@@ -21,6 +22,46 @@ const GAS_COST_MULTIPLIER = 20n;
  * If gas exceeds this threshold, the bridge is not economically worthwhile.
  */
 const MAX_GAS_PERCENT_THRESHOLD = 10n;
+const RECOVERABLE_MAX_TRANSFER_ERROR_MESSAGES = [
+    'balance may be insufficient',
+    'transfer amount exceeds balance',
+    'insufficient balance',
+];
+function hasRecoverableMaxTransferErrorMessage(message) {
+    const normalized = message.toLowerCase();
+    return (normalized.includes('unpredictable_gas_limit') ||
+        RECOVERABLE_MAX_TRANSFER_ERROR_MESSAGES.some((pattern) => normalized.includes(pattern)));
+}
+function isRecoverableMaxTransferProbeError(error) {
+    const seen = new Set();
+    const stack = [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;
+        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;
+}
 /**
  * Executes inventory-based rebalances for chains that don't support MovableCollateralRouter.
  *
@@ -169,6 +210,9 @@ export class InventoryRebalancer {
         }
         return total;
     }
+    formatLocalAmount(amount, token) {
+        return fromWei(amount.toString(), token.decimals);
+    }
     /**
      * Get the effective available inventory for a chain, accounting for
      * inventory already consumed during this execution cycle.
@@ -351,45 +395,96 @@ export class InventoryRebalancer {
         this.logger.info({
             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);
         this.logger.info({
             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');
         // Calculate transfer costs including max transferable and min viable amounts
         // transferRemote is called FROM destination TO origin (swapped direction)
         const costs = await calculateTransferCosts(destination, // FROM chain (where transferRemote is called)
         origin, // TO chain (where Hyperlane message goes)
-        availableInventory, amount, this.multiProvider, this.warpCore.multiProvider, this.getTokenForChain.bind(this), this.getInventorySignerAddress(destination), isNativeTokenStandard, this.logger);
-        const { maxTransferable, minViableTransfer } = costs;
+        availableInventory, requestedLocalAmount, this.multiProvider, this.warpCore.multiProvider, this.getTokenForChain.bind(this), executionSender, isNativeTokenStandard, this.logger);
+        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
         const totalInventory = this.getTotalInventory([]);
         this.logger.info({
             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');
             await this.actionTracker.completeRebalanceIntent(intent.id);
@@ -405,156 +500,199 @@ export class InventoryRebalancer {
             ...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 result = await this.executeTransferRemote(swappedRoute, intent, costs.gasQuote);
+            const fulfilledCanonicalAmount = normalizeToCanonical(requestedLocalAmount, sourceToken);
+            const result = await this.executeTransferRemote(swappedRoute, intent, 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 = {
-                ...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');
-            // 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({
-                    origin,
-                    destination,
-                    amount: amount.toString(),
+            const alignedExecution = alignLocalToCanonical(maxTransferable, sourceToken);
+            if (alignedExecution.messageAmount === 0n) {
+                this.logger.info({
                     intentId: intent.id,
-                }, 'No inventory available on any monitored chain');
-                return {
-                    route,
-                    success: false,
-                    error: 'No inventory available on any monitored chain',
-                };
+                    maxTransferable: maxTransferable.toString(),
+                }, 'Skipping partial transferRemote because available local amount cannot produce canonical progress');
             }
-            // NEW: Calculate max viable amount for each source chain
-            // This uses the quote API to determine gas costs upfront
-            const viableSources = [];
-            for (const source of allSources) {
-                const maxViable = await this.calculateMaxViableBridgeAmount(source.chain, destination, source.availableAmount, route.externalBridge);
-                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({
-                    targetChain: destination,
-                    sourcesChecked: allSources.length,
-                    intentId: intent.id,
-                }, 'No viable bridge sources - all chains have insufficient inventory or high gas costs');
-                return {
-                    route,
-                    success: false,
-                    error: 'No viable bridge sources available',
+            else {
+                const partialSwappedRoute = {
+                    ...swappedRoute,
+                    amount: alignedExecution.localAmount,
                 };
+                const result = await this.executeTransferRemote(partialSwappedRoute, intent, alignedExecution.messageAmount);
+                this.logger.info({
+                    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(),
+                }, 'Executed partial inventory deposit, remaining will be handled in future cycles');
+                // Return original strategy route in result (not the swapped execution route)
+                return { ...result, route };
             }
-            // Create bridge plans using VIABLE amounts (gas already accounted for)
-            const targetWithBuffer = ((amount + costs.totalCost) * (100n + BRIDGE_BUFFER_PERCENT)) / 100n;
-            const bridgePlans = [];
-            let totalPlanned = 0n;
-            for (const source of viableSources) {
-                if (totalPlanned >= targetWithBuffer)
-                    break;
-                const remaining = targetWithBuffer - totalPlanned;
-                const amountFromSource = source.maxViable >= remaining ? remaining : source.maxViable; // Already gas-adjusted!
-                bridgePlans.push({
-                    chain: source.chain,
-                    amount: amountFromSource,
-                });
-                totalPlanned += amountFromSource;
+        }
+        // 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');
+            return {
+                route,
+                success: false,
+                error: 'No inventory available on any monitored chain',
+            };
+        }
+        // Calculate source capacities in destination-local units.
+        const viableSources = [];
+        for (const source of allSources) {
+            const capacity = await this.calculateBridgeCapacity(source.chain, destination, source.availableAmount, route.externalBridge);
+            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');
-            // Execute all bridges in parallel
-            const bridgeResults = await Promise.allSettled(bridgePlans.map((plan) => this.executeInventoryMovement(plan.chain, destination, plan.amount, intent, route.externalBridge)));
-            // Process results
-            let successCount = 0;
-            let totalBridged = 0n;
-            const failedErrors = [];
-            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}`);
+            }, 'No viable bridge sources - all chains have insufficient inventory or high gas costs');
+            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 = [];
+        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 = 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 totalQuotedOutputMin = 0n;
+        const failedErrors = [];
+        for (let i = 0; i < bridgeResults.length; i++) {
+            const result = bridgeResults[i];
+            const plan = bridgePlans[i];
+            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;
+                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}`,
-                };
-            }
-            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');
-            return { route, success: true };
         }
+        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,
+            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 };
     }
     /**
      * Execute a transferRemote to deposit collateral.
@@ -569,48 +707,21 @@ export class InventoryRebalancer {
      *
      * @param route - The transfer route (swapped direction)
      * @param intent - The rebalance intent being executed
-     * @param gasQuote - Pre-calculated gas quote from calculateTransferCosts
      */
-    async executeTransferRemote(route, intent, gasQuote) {
+    async executeTransferRemote(route, intent, fulfilledCanonicalAmount) {
         const { origin, destination, amount } = route;
         const originToken = this.getTokenForChain(origin);
         if (!originToken) {
             throw new Error(`No token found for origin chain: ${origin}`);
         }
         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');
-        // 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;
-        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);
-        }
+        this.logger.debug({ origin, destination, amount: amount.toString() }, 'Building transferRemote transactions for exact execution amount');
         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, 'Expected at least one transaction from WarpCore');
         this.logger.info({
@@ -651,7 +762,7 @@ export class InventoryRebalancer {
             intentId: intent.id,
             origin: this.multiProvider.getDomainId(origin),
             destination: destinationDomain,
-            amount,
+            amount: fulfilledCanonicalAmount,
             type: 'inventory_deposit',
             txHash: transferTxHash,
             messageId,
@@ -680,6 +791,7 @@ export class InventoryRebalancer {
     buildSignerAccountConfig(protocol, key, chain) {
         void chain;
         switch (protocol) {
+            case ProtocolType.Tron:
             case ProtocolType.Ethereum:
                 return { protocol, privateKey: ensure0x(key) };
             case ProtocolType.Sealevel:
@@ -707,7 +819,7 @@ export class InventoryRebalancer {
     async getTransactionReceipt(origin, txHash) {
         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);
                 if (!receipt)
@@ -718,7 +830,8 @@ export class InventoryRebalancer {
                 const provider = 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;
@@ -753,39 +866,26 @@ export class InventoryRebalancer {
         return sources.sort((a, b) => a.availableAmount > b.availableAmount ? -1 : 1);
     }
     /**
-     * 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.
      */
-    async calculateMaxViableBridgeAmount(sourceChain, targetChain, rawInventory, externalBridgeType) {
+    async calculateBridgeCapacity(sourceChain, targetChain, rawInventory, externalBridgeType) {
         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, this.getNativeTokenAddress.bind(this));
         const sourceChainId = Number(this.multiProvider.getChainId(sourceChain));
         const targetChainId = Number(this.multiProvider.getChainId(targetChain));
         try {
             const externalBridge = this.getExternalBridge(externalBridgeType);
-            const quote = await externalBridge.quote({
+            const initialQuote = await externalBridge.quote({
                 fromChain: sourceChainId,
                 toChain: targetChainId,
                 fromToken: fromTokenAddress,
@@ -794,62 +894,74 @@ export class InventoryRebalancer {
                 fromAddress: this.getInventorySignerAddress(sourceChain),
                 toAddress: this.getInventorySignerAddress(targetChain),
             });
-            // Apply 20x multiplier on quoted gas (LiFi underestimates by ~14x)
-            const estimatedGas = quote.gasCosts * GAS_COST_MULTIPLIER;
-            // 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;
+            let maxSourceInput = rawInventory;
+            let outputQuote = initialQuote;
+            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 };
+                }
+                outputQuote = await externalBridge.quote({
+                    fromChain: sourceChainId,
+                    toChain: targetChainId,
+                    fromToken: fromTokenAddress,
+                    toToken: toTokenAddress,
+                    fromAmount: maxSourceInput,
+                    fromAddress: this.getInventorySignerAddress(sourceChain),
+                    toAddress: this.getInventorySignerAddress(targetChain),
+                });
             }
-            // Max viable = inventory minus estimated gas
-            const maxViable = rawInventory - estimatedGas;
             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),
-            }, 'Calculated max viable bridge amount');
-            return maxViable;
+                maxSourceInput: maxSourceInput.toString(),
+                maxTargetOutput: outputQuote.toAmountMin.toString(),
+            }, 'Calculated bridge capacity');
+            return {
+                maxSourceInput,
+                maxTargetOutput: outputQuote.toAmountMin,
+            };
         }
         catch (error) {
             this.logger.warn({
                 sourceChain,
                 targetChain,
                 error: error.message,
-            }, 'Failed to calculate max viable bridge amount, skipping chain');
-            return 0n;
+            }, 'Failed to calculate bridge capacity, skipping chain');
+            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
      */
-    async executeInventoryMovement(sourceChain, targetChain, amount, intent, externalBridgeType) {
+    async executeInventoryMovement(sourceChain, targetChain, targetOutputAmount, maxSourceInput, quoteMode, intent, externalBridgeType) {
         const sourceToken = this.getTokenForChain(sourceChain);
         if (!sourceToken) {
             return {
@@ -878,59 +990,65 @@ export class InventoryRebalancer {
             fromTokenAddress,
             toTokenAddress,
         }, '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;
-        // 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;
-        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');
-        }
         try {
             const externalBridge = this.getExternalBridge(externalBridgeType);
-            const quote = await externalBridge.quote({
+            const fromAddress = this.getInventorySignerAddress(sourceChain);
+            const toAddress = this.getInventorySignerAddress(targetChain);
+            const quoteWithMode = async (mode) => externalBridge.quote({
                 fromChain: sourceChainId,
                 toChain: targetChainId,
                 fromToken: fromTokenAddress,
                 toToken: toTokenAddress,
-                fromAmount: effectiveAmount,
-                fromAddress: this.getInventorySignerAddress(sourceChain),
-                toAddress: this.getInventorySignerAddress(targetChain),
+                ...(mode === 'forward'
+                    ? { fromAmount: maxSourceInput }
+                    : { toAmount: targetOutputAmount }),
+                fromAddress,
+                toAddress,
             });
+            let quoteModeUsed = quoteMode;
+            let quote = await quoteWithMode(quoteModeUsed);
+            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');
+                // 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({
                 sourceChain,
                 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({
                 quoteId: quote.id,
                 tool: quote.tool,
@@ -957,6 +1075,8 @@ export class InventoryRebalancer {
                 txHash: result.txHash,
                 intentId: intent.id,
             }, '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),
@@ -974,19 +1094,27 @@ export class InventoryRebalancer {
                 amountConsumed: inputRequired.toString(),
                 totalConsumed: (currentConsumed + inputRequired).toString(),
             }, '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.message,
+                error: errorMessage,
             }, 'Failed to execute inventory movement');
             return {
                 success: false,
-                error: error.message,
+                error: errorMessage,
             };
         }
     }