@humanode-hyperlane/rebalancer 27.2.2-humanode.1 → 1029.1.0

package/dist/core/InventoryRebalancer.test.js

@@ -3,8 +3,8 @@ import chaiAsPromised from 'chai-as-promised';
 import { Wallet } from 'ethers';
 import { pino } from 'pino';
 import Sinon from 'sinon';
-import { ProviderType, TokenStandard, WarpTxCategory, } from '@humanode-hyperlane/sdk';
-import { ProtocolType } from '@humanode-hyperlane/utils';
+import { HyperlaneCore, ProviderType, TokenStandard, WarpTxCategory, } from '@humanode-hyperlane/sdk';
+import { assert, ProtocolType } from '@humanode-hyperlane/utils';
 import { ExternalBridgeType } from '../config/types.js';
 import { createMockBridgeQuote } from '../test/lifiMocks.js';
 import { InventoryRebalancer, } from './InventoryRebalancer.js';
@@ -123,6 +123,7 @@ describe('InventoryRebalancer E2E', () => {
                 }),
             },
             findToken: Sinon.stub().returns(null),
+            getMaxTransferAmount: Sinon.stub().callsFake(async ({ balance }) => balance),
             getTransferRemoteTxs: Sinon.stub().resolves([
                 {
                     category: 'transfer',
@@ -230,6 +231,18 @@ describe('InventoryRebalancer E2E', () => {
         actionTracker.createRebalanceIntent.resolves(intent);
         return intent;
     }
+    function mockSuccessfulBridge(fromAmount, toAmount) {
+        bridge.quote.resolves(createMockBridgeQuote({
+            fromAmount,
+            toAmount,
+            toAmountMin: toAmount,
+        }));
+        bridge.execute.resolves({
+            txHash: '0xBridgeTxHash',
+            fromChain: 42161,
+            toChain: 1399811149,
+        });
+    }
     describe('Basic Inventory Rebalance (Sufficient Inventory)', () => {
         // NOTE: Strategy route is arbitrum (surplus) → solana (deficit)
         // But execution calls transferRemote FROM solana TO arbitrum (swapped direction)
@@ -323,10 +336,137 @@ describe('InventoryRebalancer E2E', () => {
             const actionParams = actionTracker.createRebalanceAction.lastCall.args[0];
             expect(actionParams.txHash).to.equal('0xSolanaTxHash');
         });
+        it('denormalizes inventory execution amounts but records canonical deposit amount', async () => {
+            const route = createTestRoute({ amount: 1000000n });
+            createTestIntent({ amount: 1000000n });
+            warpCore.tokens.find((t) => t.chainName === SOLANA_CHAIN).scale = {
+                numerator: 1n,
+                denominator: 1000000000000n,
+            };
+            inventoryRebalancer.setInventoryBalances({
+                [SOLANA_CHAIN]: 1000000000000000000n,
+                [ARBITRUM_CHAIN]: 0n,
+            });
+            const results = await inventoryRebalancer.rebalance([route]);
+            expect(results).to.have.lengthOf(1);
+            expect(results[0].success).to.be.true;
+            const txParams = warpCore.getTransferRemoteTxs.firstCall.args[0];
+            expect(txParams.originTokenAmount.amount).to.equal(1000000000000000000n);
+            const actionParams = actionTracker.createRebalanceAction.lastCall.args[0];
+            expect(actionParams.amount).to.equal(1000000n);
+        });
+    });
+    it('sendAndConfirmInventoryTx uses the EVM-like signer path for Tron txs', async () => {
+        const TRON_CHAIN = 'tron';
+        config.inventorySigners[ProtocolType.Tron] = {
+            address: INVENTORY_SIGNER,
+            key: TEST_PRIVATE_KEY,
+        };
+        const getChainMetadata = (chain) => ({
+            name: chain,
+            protocol: chain === TRON_CHAIN ? ProtocolType.Tron : ProtocolType.Ethereum,
+            blocks: { reorgPeriod: 2 },
+            rpcUrls: [{ http: 'http://127.0.0.1:9090/jsonrpc' }],
+        });
+        warpCore.multiProvider.getChainMetadata.callsFake(getChainMetadata);
+        multiProvider.getChainMetadata.callsFake(getChainMetadata);
+        warpCore.multiProvider.toMultiProvider =
+            Sinon.stub().returns(multiProvider);
+        const sendFn = inventoryRebalancer.sendAndConfirmInventoryTx.bind(inventoryRebalancer);
+        const result = await sendFn(TRON_CHAIN, {
+            category: WarpTxCategory.Transfer,
+            type: ProviderType.Tron,
+            transaction: {
+                to: '0xRouterAddress',
+                data: '0xTransferRemoteData',
+                value: 1000000n,
+            },
+        });
+        expect(result).to.deep.equal({ txHash: '0xTransferRemoteTxHash' });
+        expect(multiProvider.setSigner.calledOnce).to.be.true;
+        expect(multiProvider.sendTransaction.calledOnceWithExactly(TRON_CHAIN, {
+            to: '0xRouterAddress',
+            data: '0xTransferRemoteData',
+            value: 1000000n,
+        }, { waitConfirmations: 2 })).to.be.true;
+    });
+    it('buildSignerAccountConfig returns correct config for Tron protocol', () => {
+        config.inventorySigners[ProtocolType.Tron] = {
+            address: INVENTORY_SIGNER,
+            key: TEST_PRIVATE_KEY,
+        };
+        const buildFn = inventoryRebalancer.buildSignerAccountConfig.bind(inventoryRebalancer);
+        const result = buildFn(ProtocolType.Tron, TEST_PRIVATE_KEY, 'tron');
+        expect(result.protocol).to.equal(ProtocolType.Tron);
+        expect(result.privateKey).to.equal(TEST_PRIVATE_KEY);
+        // Tron uses same 0x-prefixed hex key format as Ethereum
+        expect(result.privateKey.startsWith('0x')).to.be.true;
+    });
+    it('getTransactionReceipt returns EthersV5 type for Tron chain', async () => {
+        const TRON_CHAIN = 'tron';
+        const mockReceipt = {
+            transactionHash: '0xTronReceipt',
+            logs: [],
+        };
+        warpCore.multiProvider.getChainMetadata.callsFake((chain) => ({
+            name: chain,
+            protocol: chain === TRON_CHAIN ? ProtocolType.Tron : ProtocolType.Ethereum,
+        }));
+        warpCore.multiProvider.getEthersV5Provider.returns({
+            getTransactionReceipt: Sinon.stub().resolves(mockReceipt),
+        });
+        const getReceiptFn = inventoryRebalancer.getTransactionReceipt.bind(inventoryRebalancer);
+        const receipt = await getReceiptFn(TRON_CHAIN, '0xTronTxHash');
+        expect(receipt).to.not.be.undefined;
+        expect(receipt.type).to.equal(ProviderType.EthersV5);
+        expect(receipt.receipt).to.deep.equal(mockReceipt);
+    });
+    it('extractDispatchedMessageId returns Tron message ids via the EthersV5 path', async () => {
+        const TRON_CHAIN = 'tron';
+        const expectedMessageId = '0x1111111111111111111111111111111111111111111111111111111111111111';
+        const mockReceipt = {
+            transactionHash: '0xTronTx',
+            logs: [{}],
+        };
+        warpCore.multiProvider.getChainMetadata.callsFake((chain) => ({
+            name: chain,
+            protocol: chain === TRON_CHAIN ? ProtocolType.Tron : ProtocolType.Ethereum,
+        }));
+        const getDispatchedMessagesStub = Sinon.stub(HyperlaneCore, 'getDispatchedMessages').returns([{ id: expectedMessageId }]);
+        warpCore.multiProvider.getEthersV5Provider.returns({
+            getTransactionReceipt: Sinon.stub().resolves(mockReceipt),
+        });
+        const extractFn = inventoryRebalancer.extractDispatchedMessageId.bind(inventoryRebalancer);
+        const messageId = await extractFn(TRON_CHAIN, '0xTronTx');
+        expect(messageId).to.equal(expectedMessageId);
+        expect(getDispatchedMessagesStub.calledOnce).to.be.true;
+        expect(getDispatchedMessagesStub.firstCall.firstArg).to.equal(mockReceipt);
+    });
+    it('selects the Tron signer address from a mixed multi-protocol config', () => {
+        config.inventorySigners[ProtocolType.Tron] = {
+            address: INVENTORY_SIGNER,
+            key: TEST_PRIVATE_KEY,
+        };
+        config.inventorySigners[ProtocolType.Sealevel] = {
+            address: 'SoLANAAddReSs1234567890123456789012345678',
+            key: '1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32',
+        };
+        warpCore.multiProvider.getChainMetadata.callsFake((chain) => ({
+            name: chain,
+            protocol: chain === 'tron'
+                ? ProtocolType.Tron
+                : chain === SOLANA_CHAIN
+                    ? ProtocolType.Sealevel
+                    : ProtocolType.Ethereum,
+        }));
+        const getInventorySignerAddress = inventoryRebalancer.getInventorySignerAddress.bind(inventoryRebalancer);
+        expect(getInventorySignerAddress('tron')).to.equal(INVENTORY_SIGNER);
+        expect(getInventorySignerAddress(SOLANA_CHAIN)).to.equal('SoLANAAddReSs1234567890123456789012345678');
     });
     describe('Partial Fulfillment (Insufficient Inventory)', () => {
-        // Partial transfers happen when maxTransferable >= minViableTransfer
-        // For non-native tokens (EvmHypCollateral), minViableTransfer = 0, so partial always viable
+        // Partial transfers happen when maxTransferable >= minViableTransfer.
+        // For non-native tokens (EvmHypCollateral), minViableTransfer = 0, so any
+        // positive fee-aware maxTransferable remains viable.
         const PARTIAL_AMOUNT = BigInt(5e15); // 0.005 ETH - above threshold
         const FULL_AMOUNT = BigInt(1e16); // 0.01 ETH
         it('executes partial transferRemote when maxTransferable >= minViableTransfer', async () => {
@@ -351,6 +491,49 @@ describe('InventoryRebalancer E2E', () => {
             const actionParams = actionTracker.createRebalanceAction.firstCall.args[0];
             expect(actionParams.amount).to.equal(PARTIAL_AMOUNT);
         });
+        it('uses fee-aware maxTransferable for non-native token fees', async () => {
+            const requestedAmount = 19998000000n;
+            const availableInventory = 102466n;
+            const safeTransferAmount = 102400n;
+            warpCore.getMaxTransferAmount.resolves({ amount: safeTransferAmount });
+            const route = createTestRoute({ amount: requestedAmount });
+            createTestIntent({ amount: requestedAmount });
+            inventoryRebalancer.setInventoryBalances({
+                [SOLANA_CHAIN]: availableInventory,
+                [ARBITRUM_CHAIN]: 0n,
+            });
+            const results = await inventoryRebalancer.rebalance([route]);
+            expect(results).to.have.lengthOf(1);
+            expect(results[0].success).to.be.true;
+            expect(warpCore.getMaxTransferAmount.calledOnce).to.be.true;
+            const maxTransferArgs = warpCore.getMaxTransferAmount.firstCall.args[0];
+            expect(maxTransferArgs.balance.amount).to.equal(availableInventory);
+            expect(maxTransferArgs.destination).to.equal(ARBITRUM_CHAIN);
+            const txParams = warpCore.getTransferRemoteTxs.lastCall.args[0];
+            expect(txParams.originTokenAmount.amount).to.equal(safeTransferAmount);
+            expect(txParams).to.not.have.property('interchainFee');
+            expect(txParams).to.not.have.property('tokenFeeQuote');
+            const actionParams = actionTracker.createRebalanceAction.lastCall.args[0];
+            expect(actionParams.amount).to.equal(safeTransferAmount);
+        });
+        it('downgrades full non-native transfers to partial when fee headroom is missing', async () => {
+            const requestedAmount = 102466n;
+            const safeTransferAmount = 102400n;
+            warpCore.getMaxTransferAmount.resolves({ amount: safeTransferAmount });
+            const route = createTestRoute({ amount: requestedAmount });
+            createTestIntent({ amount: requestedAmount });
+            inventoryRebalancer.setInventoryBalances({
+                [SOLANA_CHAIN]: requestedAmount,
+                [ARBITRUM_CHAIN]: 0n,
+            });
+            const results = await inventoryRebalancer.rebalance([route]);
+            expect(results).to.have.lengthOf(1);
+            expect(results[0].success).to.be.true;
+            expect(bridge.execute.called).to.be.false;
+            const txParams = warpCore.getTransferRemoteTxs.lastCall.args[0];
+            expect(txParams.originTokenAmount.amount).to.equal(safeTransferAmount);
+            expect(txParams.originTokenAmount.amount).to.not.equal(requestedAmount);
+        });
         it('intent remains in_progress after partial fulfillment', async () => {
             const route = createTestRoute({ amount: FULL_AMOUNT });
             createTestIntent({ amount: FULL_AMOUNT });
@@ -364,6 +547,42 @@ describe('InventoryRebalancer E2E', () => {
             expect(results[0].success).to.be.true;
         });
     });
+    describe('Fee-Aware Probe Fallback', () => {
+        it('bridges when non-native destination inventory is zero', async () => {
+            const requestedAmount = 10000000000n;
+            const bufferedBridgeAmount = (requestedAmount * 105n) / 100n;
+            const route = createTestRoute({ amount: requestedAmount });
+            createTestIntent({ amount: requestedAmount });
+            inventoryRebalancer.setInventoryBalances({
+                [SOLANA_CHAIN]: 0n,
+                [ARBITRUM_CHAIN]: 20000000000n,
+            });
+            mockSuccessfulBridge(bufferedBridgeAmount, bufferedBridgeAmount);
+            const results = await inventoryRebalancer.rebalance([route]);
+            expect(results).to.have.lengthOf(1);
+            expect(results[0].success).to.be.true;
+            expect(warpCore.getMaxTransferAmount.called).to.be.false;
+            expect(warpCore.getTransferRemoteTxs.called).to.be.false;
+            expect(bridge.execute.calledOnce).to.be.true;
+            const actionParams = actionTracker.createRebalanceAction.firstCall.args[0];
+            expect(actionParams.type).to.equal('inventory_movement');
+        });
+        it('returns failure for unrelated fee-aware probe errors', async () => {
+            const route = createTestRoute();
+            createTestIntent();
+            inventoryRebalancer.setInventoryBalances({
+                [SOLANA_CHAIN]: 1n,
+                [ARBITRUM_CHAIN]: 20000000000n,
+            });
+            warpCore.getMaxTransferAmount.rejects(new Error('RPC down'));
+            const results = await inventoryRebalancer.rebalance([route]);
+            expect(results).to.have.lengthOf(1);
+            expect(results[0].success).to.be.false;
+            expect(results[0].error).to.include('RPC down');
+            expect(bridge.execute.called).to.be.false;
+            expect(actionTracker.createRebalanceAction.called).to.be.false;
+        });
+    });
     describe('No Inventory Available', () => {
         it('returns failure when no inventory on destination chain and no other source available', async () => {
             const route = createTestRoute();
@@ -507,6 +726,42 @@ describe('InventoryRebalancer E2E', () => {
             // Verify: No new intent was created (existing was continued)
             expect(actionTracker.createRebalanceIntent.called).to.be.false;
         });
+        it('continues existing intent by bridging after recoverable fee-aware probe failure', async () => {
+            const existingIntent = createTestIntent({
+                id: 'existing-intent',
+                status: 'in_progress',
+                amount: 10000000000n,
+                externalBridge: ExternalBridgeType.LiFi,
+            });
+            const recoverableProbeError = new Error('Fee probe failed');
+            recoverableProbeError.cause = {
+                code: 'UNPREDICTABLE_GAS_LIMIT',
+                message: 'execution reverted: ERC20: transfer amount exceeds balance',
+            };
+            actionTracker.getPartiallyFulfilledInventoryIntents.resolves([
+                {
+                    intent: existingIntent,
+                    completedAmount: 0n,
+                    remaining: 10000000000n,
+                    hasInflightDeposit: false,
+                },
+            ]);
+            inventoryRebalancer.setInventoryBalances({
+                [SOLANA_CHAIN]: 1n,
+                [ARBITRUM_CHAIN]: 20000000000n,
+            });
+            warpCore.getMaxTransferAmount.rejects(recoverableProbeError);
+            mockSuccessfulBridge(10500000000n, 10500000000n);
+            const results = await inventoryRebalancer.rebalance([
+                createTestRoute({ amount: 5000000000n }),
+            ]);
+            expect(results).to.have.lengthOf(1);
+            expect(results[0].success).to.be.true;
+            expect(bridge.execute.calledOnce).to.be.true;
+            expect(actionTracker.createRebalanceIntent.called).to.be.false;
+            const actionParams = actionTracker.createRebalanceAction.firstCall.args[0];
+            expect(actionParams.type).to.equal('inventory_movement');
+        });
     });
     describe('Error Handling', () => {
         it('handles transaction send failure', async () => {
@@ -1190,6 +1445,56 @@ describe('InventoryRebalancer E2E', () => {
             // Verify: Bridge was called twice (once for each source)
             expect(bridge.execute.callCount).to.equal(2);
         });
+        it('does not inflate each split bridge plan to minViableTransfer', async () => {
+            const amount = 7000000000000000n;
+            const perChainInventory = 6000000000000000n;
+            const reservedGas = 1000000000n;
+            for (const token of warpCore.tokens) {
+                if (token.chainName === ARBITRUM_CHAIN ||
+                    token.chainName === SOLANA_CHAIN ||
+                    token.chainName === BASE_CHAIN) {
+                    token.standard = TokenStandard.EvmHypNative;
+                }
+            }
+            const route = createTestRoute({ amount });
+            createTestIntent({ amount });
+            inventoryRebalancer.setInventoryBalances({
+                [SOLANA_CHAIN]: 0n,
+                [ARBITRUM_CHAIN]: perChainInventory,
+                [BASE_CHAIN]: perChainInventory,
+            });
+            bridge.quote.callsFake(async (params) => createMockBridgeQuote({
+                fromAmount: params.fromAmount ?? params.toAmount,
+                toAmount: params.toAmount ?? params.fromAmount,
+                toAmountMin: params.toAmount ?? params.fromAmount,
+                requestParams: params.toAmount !== undefined
+                    ? { ...params, toAmount: params.toAmount }
+                    : { ...params, fromAmount: params.fromAmount },
+            }));
+            bridge.execute.resolves({
+                txHash: '0xBridgeTxHash',
+                fromChain: 42161,
+                toChain: 1399811149,
+            });
+            const results = await inventoryRebalancer.rebalance([route]);
+            expect(results).to.have.lengthOf(1);
+            expect(results[0].success).to.be.true;
+            expect(bridge.execute.callCount).to.equal(2);
+            const maxPerSourceOutput = perChainInventory - reservedGas;
+            const executionQuoteRequests = bridge.quote
+                .getCalls()
+                .slice(-2)
+                .map((call) => call.args[0]);
+            expect(executionQuoteRequests).to.have.lengthOf(2);
+            const forwardQuoteRequests = executionQuoteRequests.filter((params) => params.fromAmount !== undefined);
+            const reverseQuoteRequests = executionQuoteRequests.filter((params) => params.toAmount !== undefined);
+            const forwardAmounts = forwardQuoteRequests.map((params) => params.fromAmount);
+            expect(forwardQuoteRequests.length + reverseQuoteRequests.length).to.equal(2);
+            expect(forwardQuoteRequests.length).to.be.greaterThan(0);
+            expect(forwardAmounts.every((amount) => amount <= maxPerSourceOutput)).to
+                .be.true;
+            expect(reverseQuoteRequests.every((params) => params.toAmount <= maxPerSourceOutput)).to.be.true;
+        });
         it('applies 5% buffer to total bridge amount', async () => {
             // Need 1 ETH -> should plan to bridge 1.05 ETH total (with 5% buffer)
             const amount = BigInt(1e18); // 1 ETH
@@ -1201,14 +1506,18 @@ describe('InventoryRebalancer E2E', () => {
                 [SOLANA_CHAIN]: 0n,
                 [ARBITRUM_CHAIN]: availableInventory,
             });
-            // Capture the quote amount from executeInventoryMovement
-            // (calculateMaxViableBridgeAmount doesn't quote for ERC20 tokens)
-            let quotedFromAmount;
+            let quotedTargetOutput;
             bridge.quote.callsFake(async (params) => {
-                quotedFromAmount = params.fromAmount;
+                if (params.toAmount !== undefined) {
+                    quotedTargetOutput = params.toAmount;
+                }
                 return createMockBridgeQuote({
                     fromAmount: params.fromAmount ?? params.toAmount,
-                    toAmount: params.fromAmount ?? params.toAmount,
+                    toAmount: params.toAmount ?? params.fromAmount,
+                    toAmountMin: params.toAmount ?? params.fromAmount,
+                    requestParams: params.toAmount !== undefined
+                        ? { ...params, toAmount: params.toAmount }
+                        : { ...params, fromAmount: params.fromAmount },
                 });
             });
             bridge.execute.resolves({
@@ -1218,10 +1527,359 @@ describe('InventoryRebalancer E2E', () => {
             });
             await inventoryRebalancer.rebalance([route]);
             // Verify: 5% buffer applied (1 ETH * 1.05 = 1.05 ETH)
-            // The bridge plan uses pre-validated amounts (for ERC20, full inventory available)
-            // But the target is (amount * 105%), so if source has >= target, we bridge exactly target
             const expectedWithBuffer = (amount * 105n) / 100n;
-            expect(quotedFromAmount).to.equal(expectedWithBuffer);
+            expect(quotedTargetOutput).to.equal(expectedWithBuffer);
+        });
+        it('bridges only the mixed-decimal shortfall after dust partial skip', async () => {
+            const canonicalAmount = 1n;
+            const destinationDust = 1000000000000n - 1n;
+            const sourceInventory = 1000000000000n;
+            warpCore.tokens.find((t) => t.chainName === SOLANA_CHAIN).scale = {
+                numerator: 1n,
+                denominator: 1000000000000n,
+            };
+            const route = createTestRoute({ amount: canonicalAmount });
+            createTestIntent({ amount: canonicalAmount });
+            inventoryRebalancer.setInventoryBalances({
+                [SOLANA_CHAIN]: destinationDust,
+                [ARBITRUM_CHAIN]: sourceInventory,
+            });
+            let reverseQuoteTargetOutput;
+            bridge.quote.callsFake(async (params) => {
+                if (params.toAmount !== undefined) {
+                    reverseQuoteTargetOutput = params.toAmount;
+                }
+                return createMockBridgeQuote({
+                    fromAmount: params.fromAmount ?? params.toAmount,
+                    toAmount: params.toAmount ?? params.fromAmount,
+                    toAmountMin: params.toAmount ?? params.fromAmount,
+                    requestParams: params.toAmount !== undefined
+                        ? { ...params, toAmount: params.toAmount }
+                        : { ...params, fromAmount: params.fromAmount },
+                });
+            });
+            bridge.execute.resolves({
+                txHash: '0xBridgeTxHash',
+                fromChain: 42161,
+                toChain: 1399811149,
+            });
+            const results = await inventoryRebalancer.rebalance([route]);
+            expect(results).to.have.lengthOf(1);
+            expect(results[0].success).to.be.true;
+            expect(warpCore.getTransferRemoteTxs.called).to.be.false;
+            expect(bridge.execute.calledOnce).to.be.true;
+            expect(reverseQuoteTargetOutput).to.equal(1n);
+        });
+        it('plans LiFi target output in destination-local units for mixed-decimal routes', async () => {
+            const canonicalAmount = 1000000n;
+            const availableInventory = BigInt(2e18);
+            warpCore.tokens.find((t) => t.chainName === SOLANA_CHAIN).scale = {
+                numerator: 1n,
+                denominator: 1000000000000n,
+            };
+            const route = createTestRoute({ amount: canonicalAmount });
+            createTestIntent({ amount: canonicalAmount });
+            inventoryRebalancer.setInventoryBalances({
+                [SOLANA_CHAIN]: 0n,
+                [ARBITRUM_CHAIN]: availableInventory,
+            });
+            let quotedTargetOutput;
+            bridge.quote.callsFake(async (params) => {
+                if (params.toAmount !== undefined) {
+                    quotedTargetOutput = params.toAmount;
+                }
+                return createMockBridgeQuote({
+                    fromAmount: params.fromAmount ?? params.toAmount,
+                    toAmount: params.toAmount ?? params.fromAmount,
+                    toAmountMin: params.toAmount ?? params.fromAmount,
+                    requestParams: params.toAmount !== undefined
+                        ? { ...params, toAmount: params.toAmount }
+                        : { ...params, fromAmount: params.fromAmount },
+                });
+            });
+            bridge.execute.resolves({
+                txHash: '0xBridgeTxHash',
+                fromChain: 42161,
+                toChain: 1399811149,
+            });
+            await inventoryRebalancer.rebalance([route]);
+            expect(quotedTargetOutput).to.equal(1050000000000000000n);
+        });
+        it('retries forward execution when reverse quote exceeds planned source capacity', async () => {
+            const amount = BigInt(1e18);
+            const sourceInventory = BigInt(2e18);
+            const targetWithBuffer = (amount * 105n) / 100n;
+            const route = createTestRoute({ amount });
+            createTestIntent({ amount });
+            inventoryRebalancer.setInventoryBalances({
+                [SOLANA_CHAIN]: 0n,
+                [ARBITRUM_CHAIN]: sourceInventory,
+            });
+            bridge.quote
+                .onFirstCall()
+                .resolves(createMockBridgeQuote({
+                fromAmount: sourceInventory,
+                toAmount: sourceInventory,
+                toAmountMin: sourceInventory,
+                requestParams: {
+                    fromChain: 42161,
+                    toChain: 1399811149,
+                    fromToken: '0xCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC',
+                    toToken: '0xCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC',
+                    fromAddress: '0xAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA',
+                    toAddress: '0xAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA',
+                    fromAmount: sourceInventory,
+                },
+            }))
+                .onSecondCall()
+                .resolves(createMockBridgeQuote({
+                fromAmount: sourceInventory + 1n,
+                toAmount: targetWithBuffer,
+                toAmountMin: targetWithBuffer,
+                requestParams: {
+                    fromChain: 42161,
+                    toChain: 1399811149,
+                    fromToken: '0xCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC',
+                    toToken: '0xCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC',
+                    fromAddress: '0xAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA',
+                    toAddress: '0xAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA',
+                    toAmount: targetWithBuffer,
+                },
+            }))
+                .onThirdCall()
+                .resolves(createMockBridgeQuote({
+                fromAmount: sourceInventory,
+                toAmount: targetWithBuffer - 1n,
+                toAmountMin: targetWithBuffer - 1n,
+                requestParams: {
+                    fromChain: 42161,
+                    toChain: 1399811149,
+                    fromToken: '0xCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC',
+                    toToken: '0xCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC',
+                    fromAddress: '0xAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA',
+                    toAddress: '0xAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA',
+                    fromAmount: sourceInventory,
+                },
+            }));
+            bridge.execute.resolves({
+                txHash: '0xBridgeTxHash',
+                fromChain: 42161,
+                toChain: 1399811149,
+            });
+            const results = await inventoryRebalancer.rebalance([route]);
+            expect(results).to.have.lengthOf(1);
+            expect(results[0].success).to.be.true;
+            expect(bridge.execute.calledOnce).to.be.true;
+            expect(bridge.quote.callCount).to.equal(3);
+            expect(bridge.quote.getCall(1).args[0].toAmount).to.equal(targetWithBuffer);
+            expect(bridge.quote.getCall(2).args[0].fromAmount).to.equal(sourceInventory);
+            expect(bridge.quote.getCall(2).args[0].toAmount).to.be.undefined;
+        });
+        it('fails when forward retry still exceeds planned source capacity', async () => {
+            const amount = BigInt(1e18);
+            const sourceInventory = BigInt(2e18);
+            const targetWithBuffer = (amount * 105n) / 100n;
+            const route = createTestRoute({ amount });
+            createTestIntent({ amount });
+            inventoryRebalancer.setInventoryBalances({
+                [SOLANA_CHAIN]: 0n,
+                [ARBITRUM_CHAIN]: sourceInventory,
+            });
+            bridge.quote
+                .onFirstCall()
+                .resolves(createMockBridgeQuote({
+                fromAmount: sourceInventory,
+                toAmount: sourceInventory,
+                toAmountMin: sourceInventory,
+                requestParams: {
+                    fromChain: 42161,
+                    toChain: 1399811149,
+                    fromToken: '0xCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC',
+                    toToken: '0xCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC',
+                    fromAddress: '0xAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA',
+                    toAddress: '0xAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA',
+                    fromAmount: sourceInventory,
+                },
+            }))
+                .onSecondCall()
+                .resolves(createMockBridgeQuote({
+                fromAmount: sourceInventory + 1n,
+                toAmount: targetWithBuffer,
+                toAmountMin: targetWithBuffer,
+                requestParams: {
+                    fromChain: 42161,
+                    toChain: 1399811149,
+                    fromToken: '0xCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC',
+                    toToken: '0xCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC',
+                    fromAddress: '0xAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA',
+                    toAddress: '0xAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA',
+                    toAmount: targetWithBuffer,
+                },
+            }))
+                .onThirdCall()
+                .resolves(createMockBridgeQuote({
+                fromAmount: sourceInventory + 1n,
+                toAmount: targetWithBuffer - 1n,
+                toAmountMin: targetWithBuffer - 1n,
+                requestParams: {
+                    fromChain: 42161,
+                    toChain: 1399811149,
+                    fromToken: '0xCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC',
+                    toToken: '0xCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC',
+                    fromAddress: '0xAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA',
+                    toAddress: '0xAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA',
+                    fromAmount: sourceInventory,
+                },
+            }));
+            const results = await inventoryRebalancer.rebalance([route]);
+            expect(results).to.have.lengthOf(1);
+            expect(results[0].success).to.be.false;
+            expect(results[0].error).to.include('All inventory movements failed');
+            expect(results[0].error).to.include('exceeded planned source capacity');
+            expect(bridge.quote.callCount).to.equal(3);
+            expect(bridge.execute.called).to.be.false;
+            expect(bridge.quote.getCall(1).args[0].toAmount).to.equal(targetWithBuffer);
+            expect(bridge.quote.getCall(2).args[0].fromAmount).to.equal(sourceInventory);
+            expect(bridge.quote.getCall(2).args[0].toAmount).to.be.undefined;
+        });
+        it('fails gracefully when execute-time bridge quote rejects', async () => {
+            const amount = BigInt(1e18);
+            const sourceInventory = BigInt(2e18);
+            const route = createTestRoute({ amount });
+            createTestIntent({ amount });
+            inventoryRebalancer.setInventoryBalances({
+                [SOLANA_CHAIN]: 0n,
+                [ARBITRUM_CHAIN]: sourceInventory,
+            });
+            bridge.quote
+                .onFirstCall()
+                .resolves(createMockBridgeQuote({
+                fromAmount: sourceInventory,
+                toAmount: sourceInventory,
+                toAmountMin: sourceInventory,
+                requestParams: {
+                    fromChain: 42161,
+                    toChain: 1399811149,
+                    fromToken: '0xCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC',
+                    toToken: '0xCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC',
+                    fromAddress: '0xAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA',
+                    toAddress: '0xAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA',
+                    fromAmount: sourceInventory,
+                },
+            }))
+                .onSecondCall()
+                .rejects(new Error('LiFi API timeout'));
+            const results = await inventoryRebalancer.rebalance([route]);
+            expect(results).to.have.lengthOf(1);
+            expect(results[0].success).to.be.false;
+            expect(results[0].error).to.include('All inventory movements failed');
+            expect(results[0].error).to.include('LiFi API timeout');
+            expect(bridge.quote.callCount).to.equal(2);
+            expect(bridge.execute.called).to.be.false;
+        });
+        it('preserves non-Error rejection reasons from parallel bridge execution', async () => {
+            const amount = BigInt(1e18);
+            const sourceInventory = BigInt(2e18);
+            const route = createTestRoute({ amount });
+            createTestIntent({ amount });
+            inventoryRebalancer.setInventoryBalances({
+                [SOLANA_CHAIN]: 0n,
+                [ARBITRUM_CHAIN]: sourceInventory,
+            });
+            bridge.quote.onFirstCall().resolves(createMockBridgeQuote({
+                fromAmount: sourceInventory,
+                toAmount: sourceInventory,
+                toAmountMin: sourceInventory,
+                requestParams: {
+                    fromChain: 42161,
+                    toChain: 1399811149,
+                    fromToken: '0xCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC',
+                    toToken: '0xCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC',
+                    fromAddress: '0xAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA',
+                    toAddress: '0xAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA',
+                    fromAmount: sourceInventory,
+                },
+            }));
+            // Simulate a foreign promise rejecting with a non-Error reason at runtime.
+            const rejectionReason = 'bridge exploded';
+            const executeInventoryMovementStub = Sinon.stub(inventoryRebalancer, 'executeInventoryMovement').callsFake(() => Promise.resolve().then(() => {
+                throw rejectionReason;
+            }));
+            const results = await inventoryRebalancer.rebalance([route]);
+            expect(results).to.have.lengthOf(1);
+            expect(results[0].success).to.be.false;
+            expect(results[0].error).to.include('All inventory movements failed');
+            expect(results[0].error).to.include('arbitrum: bridge exploded');
+            expect(executeInventoryMovementStub.calledOnce).to.be.true;
+            expect(bridge.execute.called).to.be.false;
+            executeInventoryMovementStub.restore();
+        });
+        it('logs actual successful bridge output floors instead of planned output totals', async () => {
+            const amount = BigInt(1e18);
+            const perChainInventory = BigInt(0.6e18);
+            const logger = {
+                info: Sinon.stub(),
+                debug: Sinon.stub(),
+                warn: Sinon.stub(),
+                error: Sinon.stub(),
+            };
+            const localRebalancer = new InventoryRebalancer(config, actionTracker, { lifi: bridge }, warpCore, multiProvider, logger);
+            const route = createTestRoute({ amount });
+            createTestIntent({ amount });
+            localRebalancer.setInventoryBalances({
+                [SOLANA_CHAIN]: 0n,
+                [ARBITRUM_CHAIN]: perChainInventory,
+                [BASE_CHAIN]: perChainInventory,
+            });
+            bridge.quote
+                .onCall(0)
+                .resolves(createMockBridgeQuote({
+                fromAmount: perChainInventory,
+                toAmount: BigInt(0.525e18),
+                toAmountMin: BigInt(0.525e18),
+            }))
+                .onCall(1)
+                .resolves(createMockBridgeQuote({
+                fromAmount: perChainInventory,
+                toAmount: BigInt(0.525e18),
+                toAmountMin: BigInt(0.525e18),
+            }))
+                .onCall(2)
+                .resolves(createMockBridgeQuote({
+                fromAmount: perChainInventory,
+                toAmount: BigInt(0.505e18),
+                toAmountMin: BigInt(0.5e18),
+            }))
+                .onCall(3)
+                .resolves(createMockBridgeQuote({
+                fromAmount: perChainInventory,
+                toAmount: BigInt(0.515e18),
+                toAmountMin: BigInt(0.51e18),
+            }));
+            bridge.execute
+                .onFirstCall()
+                .resolves({
+                txHash: '0xSuccessTxHash1',
+                fromChain: 42161,
+                toChain: 1399811149,
+            })
+                .onSecondCall()
+                .resolves({
+                txHash: '0xSuccessTxHash2',
+                fromChain: 8453,
+                toChain: 1399811149,
+            });
+            const results = await localRebalancer.rebalance([route]);
+            expect(results).to.have.lengthOf(1);
+            expect(results[0].success).to.be.true;
+            expect(bridge.execute.callCount).to.equal(2);
+            const summaryCall = logger.info
+                .getCalls()
+                .find((call) => call.args[0] &&
+                typeof call.args[0] === 'object' &&
+                Object.prototype.hasOwnProperty.call(call.args[0], 'totalQuotedOutputMin'));
+            assert(summaryCall, 'Expected summary log with totalQuotedOutputMin');
+            expect(summaryCall.args[0].totalQuotedOutputMin).to.equal(BigInt(1.01e18).toString());
         });
         it('continues when some bridges fail', async () => {
             const amount = BigInt(1e18);
@@ -1402,11 +2060,31 @@ describe('InventoryRebalancer E2E', () => {
                 [ARBITRUM_CHAIN]: tokenBalance,
             });
             // Quote with high gas costs (but for ERC20, this shouldn't trigger viability check)
-            bridge.quote.resolves(createMockBridgeQuote({
-                fromAmount: BigInt(1.05e18),
-                toAmount: BigInt(1e18),
+            bridge.quote
+                .onFirstCall()
+                .resolves(createMockBridgeQuote({
+                fromAmount: tokenBalance,
+                toAmount: tokenBalance,
+                toAmountMin: tokenBalance,
                 gasCosts: BigInt(1e18), // Very high gas (would fail viability if this were native)
                 feeCosts: 0n,
+            }))
+                .onSecondCall()
+                .resolves(createMockBridgeQuote({
+                fromAmount: tokenBalance,
+                toAmount: tokenBalance,
+                toAmountMin: tokenBalance,
+                gasCosts: BigInt(1e18),
+                feeCosts: 0n,
+                requestParams: {
+                    fromChain: 42161,
+                    toChain: 1399811149,
+                    fromToken: '0xCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC',
+                    toToken: '0xCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC',
+                    fromAddress: '0xAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA',
+                    toAddress: '0xAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA',
+                    toAmount: tokenBalance,
+                },
             }));
             bridge.execute.resolves({
                 txHash: '0xERC20BridgeTxHash',
@@ -1418,6 +2096,9 @@ describe('InventoryRebalancer E2E', () => {
             expect(results).to.have.lengthOf(1);
             expect(results[0].success).to.be.true;
             expect(bridge.execute.calledOnce).to.be.true;
+            expect(bridge.quote.callCount).to.equal(2);
+            expect(bridge.quote.getCall(1).args[0].fromAmount).to.equal(tokenBalance);
+            expect(bridge.quote.getCall(1).args[0].toAmount).to.be.undefined;
         });
         it('calculates max viable amount as inventory minus (gasCosts * 20) for native tokens', async () => {
             // Setup: Native token with enough balance for viable bridge
@@ -1447,11 +2128,40 @@ describe('InventoryRebalancer E2E', () => {
             // maxViable = 1 ETH - 0.02 ETH = 0.98 ETH
             // 10% threshold = 0.1 ETH, estimatedGas (0.02) < threshold → viable
             const gasCosts = BigInt(0.001e18); // 0.001 ETH
-            bridge.quote.resolves(createMockBridgeQuote({
+            const maxViable = rawBalance - gasCosts * 20n;
+            bridge.quote
+                .onFirstCall()
+                .resolves(createMockBridgeQuote({
                 fromAmount: rawBalance,
                 toAmount: rawBalance - BigInt(1e15),
+                toAmountMin: rawBalance - BigInt(1e15),
                 gasCosts,
                 feeCosts: 0n,
+            }))
+                .onSecondCall()
+                .resolves(createMockBridgeQuote({
+                fromAmount: maxViable,
+                toAmount: maxViable - BigInt(1e15),
+                toAmountMin: maxViable - BigInt(1e15),
+                gasCosts,
+                feeCosts: 0n,
+            }))
+                .onThirdCall()
+                .resolves(createMockBridgeQuote({
+                fromAmount: BigInt(0.525e18),
+                toAmount: BigInt(0.525e18),
+                toAmountMin: BigInt(0.525e18),
+                gasCosts,
+                feeCosts: 0n,
+                requestParams: {
+                    fromChain: 42161,
+                    toChain: 1399811149,
+                    fromToken: '0xCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC',
+                    toToken: '0xCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC',
+                    fromAddress: '0xAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA',
+                    toAddress: '0xAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA',
+                    toAmount: BigInt(0.525e18),
+                },
             }));
             bridge.execute.resolves({
                 txHash: '0xSuccessBridgeTxHash',
@@ -1463,15 +2173,94 @@ describe('InventoryRebalancer E2E', () => {
             expect(results).to.have.lengthOf(1);
             expect(results[0].success).to.be.true;
             expect(bridge.execute.calledOnce).to.be.true;
-            // Verify: The quoted fromAmount should be the target (since maxViable > target)
-            // For the execution quote (second quote call):
-            // targetWithBuffer = (0.5 ETH) * 1.05 = 0.525 ETH (for non-inventory execution, costs are 0)
-            const executionQuoteCall = bridge.quote
-                .getCalls()
-                .find((call) => call.args[0].fromAmount !== undefined &&
-                call.args[0].fromAmount !== rawBalance);
-            // Since maxViable (0.98 ETH) > targetWithBuffer (0.525 ETH), we bridge exactly targetWithBuffer
-            expect(executionQuoteCall).to.exist;
+            expect(bridge.quote.callCount).to.equal(3);
+            expect(bridge.quote.getCall(1).args[0].fromAmount).to.equal(maxViable);
+            const executionTargetOutput = bridge.quote.getCall(2).args[0].toAmount;
+            expect(executionTargetOutput).to.be.a('bigint');
+            if (executionTargetOutput === undefined) {
+                throw new Error('Expected reverse quote to set toAmount');
+            }
+            expect(executionTargetOutput > amount).to.be.true;
+            expect(executionTargetOutput <= maxViable).to.be.true;
+        });
+        it('uses forward quote when target output exactly matches source capacity', async () => {
+            const amount = 1000n;
+            const rawBalance = 1100n;
+            const targetWithBuffer = 1050n;
+            const route = createTestRoute({ amount });
+            createTestIntent({ amount });
+            inventoryRebalancer.setInventoryBalances({
+                [SOLANA_CHAIN]: 0n,
+                [ARBITRUM_CHAIN]: rawBalance,
+            });
+            bridge.quote
+                .onFirstCall()
+                .resolves(createMockBridgeQuote({
+                fromAmount: rawBalance,
+                toAmount: targetWithBuffer,
+                toAmountMin: targetWithBuffer,
+            }))
+                .onSecondCall()
+                .resolves(createMockBridgeQuote({
+                fromAmount: rawBalance,
+                toAmount: targetWithBuffer,
+                toAmountMin: targetWithBuffer,
+            }));
+            bridge.execute.resolves({
+                txHash: '0xForwardBoundaryBridgeTxHash',
+                fromChain: 42161,
+                toChain: 1399811149,
+            });
+            const results = await inventoryRebalancer.rebalance([route]);
+            expect(results).to.have.lengthOf(1);
+            expect(results[0].success).to.be.true;
+            expect(bridge.execute.calledOnce).to.be.true;
+            expect(bridge.quote.callCount).to.equal(2);
+            expect(bridge.quote.getCall(1).args[0].fromAmount).to.equal(rawBalance);
+            expect(bridge.quote.getCall(1).args[0].toAmount).to.be.undefined;
+        });
+        it('retries reverse quote as forward when exact-output exceeds source capacity', async () => {
+            const amount = 1000n;
+            const rawBalance = 1100n;
+            const targetWithBuffer = 1050n;
+            const route = createTestRoute({ amount });
+            createTestIntent({ amount });
+            inventoryRebalancer.setInventoryBalances({
+                [SOLANA_CHAIN]: 0n,
+                [ARBITRUM_CHAIN]: rawBalance,
+            });
+            bridge.quote
+                .onFirstCall()
+                .resolves(createMockBridgeQuote({
+                fromAmount: rawBalance,
+                toAmount: 1051n,
+                toAmountMin: 1051n,
+            }))
+                .onSecondCall()
+                .resolves(createMockBridgeQuote({
+                fromAmount: rawBalance + 1n,
+                toAmount: targetWithBuffer,
+                toAmountMin: targetWithBuffer,
+            }))
+                .onThirdCall()
+                .resolves(createMockBridgeQuote({
+                fromAmount: rawBalance,
+                toAmount: 1049n,
+                toAmountMin: 1049n,
+            }));
+            bridge.execute.resolves({
+                txHash: '0xForwardFallbackBridgeTxHash',
+                fromChain: 42161,
+                toChain: 1399811149,
+            });
+            const results = await inventoryRebalancer.rebalance([route]);
+            expect(results).to.have.lengthOf(1);
+            expect(results[0].success).to.be.true;
+            expect(bridge.execute.calledOnce).to.be.true;
+            expect(bridge.quote.callCount).to.equal(3);
+            expect(bridge.quote.getCall(1).args[0].toAmount).to.equal(targetWithBuffer);
+            expect(bridge.quote.getCall(2).args[0].fromAmount).to.equal(rawBalance);
+            expect(bridge.quote.getCall(2).args[0].toAmount).to.be.undefined;
         });
         it('handles quote failures gracefully by skipping the source chain', async () => {
             // Setup: Native token where quote fails