@hyperlane-xyz/rebalancer 2.0.0 → 3.1.0

package/dist/tracking/ActionTracker.test.js

@@ -3,6 +3,7 @@ import chaiAsPromised from 'chai-as-promised';
 import { pino } from 'pino';
 import Sinon from 'sinon';
 import { EthJsonRpcBlockParameterTag } from '@hyperlane-xyz/sdk';
+import { DEFAULT_INTENT_TTL_MS } from '../config/types.js';
 import { ActionTracker } from './ActionTracker.js';
 import { InMemoryStore } from './store/InMemoryStore.js';
 chai.use(chaiAsPromised);
@@ -48,6 +49,7 @@ describe('ActionTracker', () => {
             },
             bridges: ['0xbridge1', '0xbridge2'],
             rebalancerAddress: '0xrebalancer',
+            intentTTL: DEFAULT_INTENT_TTL_MS,
         };
         tracker = new ActionTracker(transferStore, rebalanceIntentStore, rebalanceActionStore, explorerClient, core, config, testLogger);
     });
@@ -65,6 +67,7 @@ describe('ActionTracker', () => {
                     origin_tx_recipient: '0xrouter1',
                     is_delivered: false,
                     message_body: '0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000064',
+                    send_occurred_at: null,
                 },
             ];
             explorerClient.getInflightRebalanceActions.resolves(inflightMessages);
@@ -87,6 +90,86 @@ describe('ActionTracker', () => {
             expect(actions[0].status).to.equal('in_progress');
             expect(actions[0].messageId).to.equal('0xmsg1');
         });
+        it('should use send_occurred_at for createdAt when available', async () => {
+            const inflightMessages = [
+                {
+                    msg_id: '0xmsg1',
+                    origin_domain_id: 1,
+                    destination_domain_id: 2,
+                    sender: '0xrouter1',
+                    recipient: '0xrouter2',
+                    origin_tx_hash: '0xtx1',
+                    origin_tx_sender: '0xrebalancer',
+                    origin_tx_recipient: '0xrouter1',
+                    is_delivered: false,
+                    message_body: '0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000064',
+                    send_occurred_at: '2024-01-15T12:30:45',
+                },
+            ];
+            explorerClient.getInflightRebalanceActions.resolves(inflightMessages);
+            explorerClient.getInflightUserTransfers.resolves([]);
+            mailboxStub.isDelivered.resolves(false);
+            await tracker.initialize();
+            const intents = await rebalanceIntentStore.getAll();
+            expect(intents).to.have.lengthOf(1);
+            // Hasura timestamps are UTC without 'Z'; recoverAction appends 'Z' before parsing
+            const expectedMs = new Date('2024-01-15T12:30:45Z').getTime();
+            expect(intents[0].createdAt).to.equal(expectedMs);
+            const actions = await rebalanceActionStore.getAll();
+            expect(actions[0].createdAt).to.equal(expectedMs);
+        });
+        it('should fall back to Date.now() when send_occurred_at is null', async () => {
+            const before = Date.now();
+            const inflightMessages = [
+                {
+                    msg_id: '0xmsg1',
+                    origin_domain_id: 1,
+                    destination_domain_id: 2,
+                    sender: '0xrouter1',
+                    recipient: '0xrouter2',
+                    origin_tx_hash: '0xtx1',
+                    origin_tx_sender: '0xrebalancer',
+                    origin_tx_recipient: '0xrouter1',
+                    is_delivered: false,
+                    message_body: '0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000064',
+                    send_occurred_at: null,
+                },
+            ];
+            explorerClient.getInflightRebalanceActions.resolves(inflightMessages);
+            explorerClient.getInflightUserTransfers.resolves([]);
+            mailboxStub.isDelivered.resolves(false);
+            await tracker.initialize();
+            const after = Date.now();
+            const intents = await rebalanceIntentStore.getAll();
+            expect(intents[0].createdAt).to.be.at.least(before);
+            expect(intents[0].createdAt).to.be.at.most(after);
+        });
+        it('should skip action with invalid send_occurred_at timestamp', async () => {
+            const inflightMessages = [
+                {
+                    msg_id: '0xmsg1',
+                    origin_domain_id: 1,
+                    destination_domain_id: 2,
+                    sender: '0xrouter1',
+                    recipient: '0xrouter2',
+                    origin_tx_hash: '0xtx1',
+                    origin_tx_sender: '0xrebalancer',
+                    origin_tx_recipient: '0xrouter1',
+                    is_delivered: false,
+                    message_body: '0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000064',
+                    send_occurred_at: 'garbage',
+                },
+            ];
+            explorerClient.getInflightRebalanceActions.resolves(inflightMessages);
+            explorerClient.getInflightUserTransfers.resolves([]);
+            mailboxStub.isDelivered.resolves(false);
+            await tracker.initialize();
+            // Invalid timestamp is caught by recoverAction's catch block, so the action is skipped
+            const intents = await rebalanceIntentStore.getAll();
+            expect(intents).to.have.lengthOf(0);
+            const actions = await rebalanceActionStore.getAll();
+            expect(actions).to.have.lengthOf(0);
+        });
         it('should skip creating action if it already exists', async () => {
             const inflightMessages = [
                 {
@@ -100,11 +183,13 @@ describe('ActionTracker', () => {
                     origin_tx_recipient: '0xrouter1',
                     is_delivered: false,
                     message_body: '0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000064',
+                    send_occurred_at: null,
                 },
             ];
             // Pre-create action
             await rebalanceActionStore.save({
                 id: '0xmsg1',
+                type: 'rebalance_message',
                 status: 'in_progress',
                 intentId: 'existing-intent',
                 messageId: '0xmsg1',
@@ -139,6 +224,7 @@ describe('ActionTracker', () => {
                     origin_tx_recipient: '0xrouter1',
                     is_delivered: false,
                     message_body: '0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000064',
+                    send_occurred_at: null,
                 },
             ];
             explorerClient.getInflightUserTransfers.resolves(inflightMessages);
@@ -176,6 +262,7 @@ describe('ActionTracker', () => {
                     origin_tx_recipient: '0xrouter1',
                     is_delivered: false,
                     message_body: '0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000064',
+                    send_occurred_at: null,
                 },
             ];
             explorerClient.getInflightUserTransfers.resolves(inflightMessages);
@@ -206,33 +293,104 @@ describe('ActionTracker', () => {
     });
     describe('syncRebalanceIntents', () => {
         it('should mark intents as complete when fully fulfilled', async () => {
+            // Intent derives completion from action states, so we need a complete action
             const intent = {
                 id: 'intent-1',
                 status: 'in_progress',
                 origin: 1,
                 destination: 2,
                 amount: 100n,
-                fulfilledAmount: 100n,
+                createdAt: Date.now(),
+                updatedAt: Date.now(),
+            };
+            const action = {
+                id: 'action-1',
+                type: 'rebalance_message',
+                status: 'complete',
+                intentId: 'intent-1',
+                messageId: '0xmsg1',
+                origin: 1,
+                destination: 2,
+                amount: 100n,
                 createdAt: Date.now(),
                 updatedAt: Date.now(),
             };
             await rebalanceIntentStore.save(intent);
+            await rebalanceActionStore.save(action);
             await tracker.syncRebalanceIntents();
             const updated = await rebalanceIntentStore.get('intent-1');
             expect(updated?.status).to.equal('complete');
         });
         it('should not mark intents as complete if not fully fulfilled', async () => {
+            // Intent with only partial completion via actions
+            const intent = {
+                id: 'intent-1',
+                status: 'in_progress',
+                origin: 1,
+                destination: 2,
+                amount: 100n,
+                createdAt: Date.now(),
+                updatedAt: Date.now(),
+            };
+            const action = {
+                id: 'action-1',
+                type: 'rebalance_message',
+                status: 'complete',
+                intentId: 'intent-1',
+                messageId: '0xmsg1',
+                origin: 1,
+                destination: 2,
+                amount: 50n, // Only partial
+                createdAt: Date.now(),
+                updatedAt: Date.now(),
+            };
+            await rebalanceIntentStore.save(intent);
+            await rebalanceActionStore.save(action);
+            await tracker.syncRebalanceIntents();
+            const updated = await rebalanceIntentStore.get('intent-1');
+            expect(updated?.status).to.equal('in_progress');
+        });
+        it('should mark unfulfilled intents as failed when TTL exceeded', async () => {
             const intent = {
                 id: 'intent-1',
                 status: 'in_progress',
                 origin: 1,
                 destination: 2,
                 amount: 100n,
-                fulfilledAmount: 50n,
+                createdAt: Date.now() - DEFAULT_INTENT_TTL_MS - 1,
+                updatedAt: Date.now(),
+            };
+            const action = {
+                id: 'action-1',
+                type: 'rebalance_message',
+                status: 'in_progress',
+                intentId: 'intent-1',
+                messageId: '0xmsg1',
+                origin: 1,
+                destination: 2,
+                amount: 50n,
                 createdAt: Date.now(),
                 updatedAt: Date.now(),
             };
             await rebalanceIntentStore.save(intent);
+            await rebalanceActionStore.save(action);
+            await tracker.syncRebalanceIntents();
+            const updatedIntent = await rebalanceIntentStore.get('intent-1');
+            expect(updatedIntent?.status).to.equal('failed');
+            const updatedAction = await rebalanceActionStore.get('action-1');
+            expect(updatedAction?.status).to.equal('failed');
+        });
+        it('should not expire intents within TTL', async () => {
+            const intent = {
+                id: 'intent-1',
+                status: 'in_progress',
+                origin: 1,
+                destination: 2,
+                amount: 100n,
+                createdAt: Date.now() - DEFAULT_INTENT_TTL_MS + 60_000,
+                updatedAt: Date.now(),
+            };
+            await rebalanceIntentStore.save(intent);
             await tracker.syncRebalanceIntents();
             const updated = await rebalanceIntentStore.get('intent-1');
             expect(updated?.status).to.equal('in_progress');
@@ -246,12 +404,12 @@ describe('ActionTracker', () => {
                 origin: 1,
                 destination: 2,
                 amount: 100n,
-                fulfilledAmount: 0n,
                 createdAt: Date.now(),
                 updatedAt: Date.now(),
             };
             const action = {
                 id: 'action-1',
+                type: 'rebalance_message',
                 status: 'in_progress',
                 intentId: 'intent-1',
                 messageId: '0xmsg1',
@@ -268,14 +426,14 @@ describe('ActionTracker', () => {
             // Action should be complete
             const updatedAction = await rebalanceActionStore.get('action-1');
             expect(updatedAction?.status).to.equal('complete');
-            // Intent should be updated and complete
+            // Intent should be complete (derived from completed action amounts)
             const updatedIntent = await rebalanceIntentStore.get('intent-1');
-            expect(updatedIntent?.fulfilledAmount).to.equal(100n);
             expect(updatedIntent?.status).to.equal('complete');
         });
         it('should not mark actions as complete if not delivered', async () => {
             const action = {
                 id: 'action-1',
+                type: 'rebalance_message',
                 status: 'in_progress',
                 intentId: 'intent-1',
                 messageId: '0xmsg1',
@@ -331,7 +489,6 @@ describe('ActionTracker', () => {
                 origin: 1,
                 destination: 2,
                 amount: 100n,
-                fulfilledAmount: 0n,
                 createdAt: Date.now(),
                 updatedAt: Date.now(),
             });
@@ -341,7 +498,6 @@ describe('ActionTracker', () => {
                 origin: 2,
                 destination: 3,
                 amount: 200n,
-                fulfilledAmount: 50n,
                 createdAt: Date.now(),
                 updatedAt: Date.now(),
             });
@@ -351,7 +507,6 @@ describe('ActionTracker', () => {
                 origin: 3,
                 destination: 1,
                 amount: 300n,
-                fulfilledAmount: 300n,
                 createdAt: Date.now(),
                 updatedAt: Date.now(),
             });
@@ -362,6 +517,214 @@ describe('ActionTracker', () => {
             expect(result[0].id).to.equal('intent-2');
         });
     });
+    describe('getPartiallyFulfilledInventoryIntents', () => {
+        it('returns not_started inventory intents', async () => {
+            // Create a not_started inventory intent (simulates failed execution before any action created)
+            await rebalanceIntentStore.save({
+                id: 'stuck-intent',
+                status: 'not_started',
+                origin: 1,
+                destination: 2,
+                amount: 1000000000000000000n, // 1 ETH
+                executionMethod: 'inventory',
+                createdAt: Date.now(),
+                updatedAt: Date.now(),
+            });
+            // Should be returned even though status is 'not_started'
+            const partialIntents = await tracker.getPartiallyFulfilledInventoryIntents();
+            expect(partialIntents).to.have.lengthOf(1);
+            expect(partialIntents[0].intent.id).to.equal('stuck-intent');
+            expect(partialIntents[0].completedAmount).to.equal(0n);
+            expect(partialIntents[0].remaining).to.equal(1000000000000000000n);
+        });
+        it('returns in_progress inventory intents with partial completion', async () => {
+            // Create an in_progress inventory intent with a completed action
+            await rebalanceIntentStore.save({
+                id: 'partial-intent',
+                status: 'in_progress',
+                origin: 1,
+                destination: 2,
+                amount: 1000000000000000000n, // 1 ETH
+                executionMethod: 'inventory',
+                createdAt: Date.now(),
+                updatedAt: Date.now(),
+            });
+            // Create a completed inventory_deposit action for partial amount
+            await rebalanceActionStore.save({
+                id: 'action-1',
+                type: 'inventory_deposit',
+                status: 'complete',
+                intentId: 'partial-intent',
+                origin: 1,
+                destination: 2,
+                amount: 400000000000000000n, // 0.4 ETH completed
+                createdAt: Date.now(),
+                updatedAt: Date.now(),
+            });
+            const partialIntents = await tracker.getPartiallyFulfilledInventoryIntents();
+            expect(partialIntents).to.have.lengthOf(1);
+            expect(partialIntents[0].intent.id).to.equal('partial-intent');
+            expect(partialIntents[0].completedAmount).to.equal(400000000000000000n);
+            expect(partialIntents[0].remaining).to.equal(600000000000000000n); // 0.6 ETH remaining
+        });
+        it('does not return non-inventory intents', async () => {
+            // Create a not_started intent without executionMethod: 'inventory'
+            await rebalanceIntentStore.save({
+                id: 'non-inventory-intent',
+                status: 'not_started',
+                origin: 1,
+                destination: 2,
+                amount: 1000000000000000000n,
+                // executionMethod is undefined - not an inventory intent
+                createdAt: Date.now(),
+                updatedAt: Date.now(),
+            });
+            const partialIntents = await tracker.getPartiallyFulfilledInventoryIntents();
+            expect(partialIntents).to.have.lengthOf(0);
+        });
+        it('returns intent with in-flight deposit and sets hasInflightDeposit flag', async () => {
+            // Setup: in_progress inventory intent (amount: 1 ETH = 1_000_000_000_000_000_000n)
+            await rebalanceIntentStore.save({
+                id: 'intent-with-inflight',
+                status: 'in_progress',
+                origin: 1,
+                destination: 2,
+                amount: 1000000000000000000n, // 1 ETH
+                executionMethod: 'inventory',
+                createdAt: Date.now(),
+                updatedAt: Date.now(),
+            });
+            // Complete inventory_deposit action (amount: 400_000_000_000_000_000n = 0.4 ETH)
+            await rebalanceActionStore.save({
+                id: 'action-complete',
+                type: 'inventory_deposit',
+                status: 'complete',
+                intentId: 'intent-with-inflight',
+                origin: 1,
+                destination: 2,
+                amount: 400000000000000000n, // 0.4 ETH completed
+                createdAt: Date.now(),
+                updatedAt: Date.now(),
+            });
+            // In_progress inventory_deposit action (amount: 300_000_000_000_000_000n = 0.3 ETH)
+            await rebalanceActionStore.save({
+                id: 'action-inflight',
+                type: 'inventory_deposit',
+                status: 'in_progress',
+                intentId: 'intent-with-inflight',
+                origin: 1,
+                destination: 2,
+                amount: 300000000000000000n, // 0.3 ETH in-flight
+                createdAt: Date.now(),
+                updatedAt: Date.now(),
+            });
+            const partialIntents = await tracker.getPartiallyFulfilledInventoryIntents();
+            expect(partialIntents).to.have.lengthOf(1);
+            expect(partialIntents[0].hasInflightDeposit).to.be.true;
+            expect(partialIntents[0].completedAmount).to.equal(400000000000000000n);
+            expect(partialIntents[0].remaining).to.equal(300000000000000000n); // 1.0 - 0.4 - 0.3
+        });
+        it('returns intent without in-flight deposit with hasInflightDeposit false', async () => {
+            // Setup: in_progress inventory intent (amount: 1 ETH)
+            await rebalanceIntentStore.save({
+                id: 'intent-no-inflight',
+                status: 'in_progress',
+                origin: 1,
+                destination: 2,
+                amount: 1000000000000000000n, // 1 ETH
+                executionMethod: 'inventory',
+                createdAt: Date.now(),
+                updatedAt: Date.now(),
+            });
+            // Complete inventory_deposit action (amount: 0.4 ETH)
+            await rebalanceActionStore.save({
+                id: 'action-complete-only',
+                type: 'inventory_deposit',
+                status: 'complete',
+                intentId: 'intent-no-inflight',
+                origin: 1,
+                destination: 2,
+                amount: 400000000000000000n, // 0.4 ETH completed
+                createdAt: Date.now(),
+                updatedAt: Date.now(),
+            });
+            // NO in_progress inventory_deposit actions
+            const partialIntents = await tracker.getPartiallyFulfilledInventoryIntents();
+            expect(partialIntents).to.have.lengthOf(1);
+            expect(partialIntents[0].hasInflightDeposit).to.be.false;
+            expect(partialIntents[0].remaining).to.equal(600000000000000000n);
+        });
+        it('returns intent when remaining is 0n but has in-flight deposit', async () => {
+            // intent.amount = 1 ETH, completedAmount = 0.7 ETH, inflightAmount = 0.3 ETH → remaining = 0n
+            await rebalanceIntentStore.save({
+                id: 'intent-zero-remaining',
+                status: 'in_progress',
+                origin: 1,
+                destination: 2,
+                amount: 1000000000000000000n, // 1 ETH
+                executionMethod: 'inventory',
+                createdAt: Date.now(),
+                updatedAt: Date.now(),
+            });
+            // 0.7 ETH already completed
+            await rebalanceActionStore.save({
+                id: 'action-complete-part',
+                type: 'inventory_deposit',
+                status: 'complete',
+                intentId: 'intent-zero-remaining',
+                origin: 1,
+                destination: 2,
+                amount: 700000000000000000n, // 0.7 ETH
+                createdAt: Date.now(),
+                updatedAt: Date.now(),
+            });
+            // 0.3 ETH in-flight — exactly fills the remaining gap
+            await rebalanceActionStore.save({
+                id: 'action-inflight-rest',
+                type: 'inventory_deposit',
+                status: 'in_progress',
+                intentId: 'intent-zero-remaining',
+                origin: 1,
+                destination: 2,
+                amount: 300000000000000000n, // 0.3 ETH in-flight
+                createdAt: Date.now(),
+                updatedAt: Date.now(),
+            });
+            const partialIntents = await tracker.getPartiallyFulfilledInventoryIntents();
+            expect(partialIntents).to.have.lengthOf(1);
+            expect(partialIntents[0].remaining).to.equal(0n);
+            expect(partialIntents[0].hasInflightDeposit).to.be.true;
+            expect(partialIntents[0].completedAmount).to.equal(700000000000000000n);
+        });
+        it('does not return fully completed intent with no in-flight deposits', async () => {
+            // intent.amount = 1 ETH, completedAmount = 1 ETH, inflightAmount = 0 → remaining = 0n, no inflight
+            await rebalanceIntentStore.save({
+                id: 'intent-fully-done',
+                status: 'in_progress',
+                origin: 1,
+                destination: 2,
+                amount: 1000000000000000000n, // 1 ETH
+                executionMethod: 'inventory',
+                createdAt: Date.now(),
+                updatedAt: Date.now(),
+            });
+            // Full amount completed
+            await rebalanceActionStore.save({
+                id: 'action-all-done',
+                type: 'inventory_deposit',
+                status: 'complete',
+                intentId: 'intent-fully-done',
+                origin: 1,
+                destination: 2,
+                amount: 1000000000000000000n, // 1 ETH — full amount
+                createdAt: Date.now(),
+                updatedAt: Date.now(),
+            });
+            const partialIntents = await tracker.getPartiallyFulfilledInventoryIntents();
+            // remaining = 0n AND inflightAmount = 0n → should NOT be returned
+            expect(partialIntents).to.have.lengthOf(0);
+        });
+    });
     describe('createRebalanceIntent', () => {
         it('should create a new intent with status not_started', async () => {
             const result = await tracker.createRebalanceIntent({
@@ -375,7 +738,6 @@ describe('ActionTracker', () => {
             expect(result.origin).to.equal(1);
             expect(result.destination).to.equal(2);
             expect(result.amount).to.equal(100n);
-            expect(result.fulfilledAmount).to.equal(0n);
             expect(result.priority).to.equal(1);
             expect(result.strategyType).to.equal('MinAmountStrategy');
             const stored = await rebalanceIntentStore.get(result.id);
@@ -390,12 +752,12 @@ describe('ActionTracker', () => {
                 origin: 1,
                 destination: 2,
                 amount: 100n,
-                fulfilledAmount: 0n,
                 createdAt: Date.now(),
                 updatedAt: Date.now(),
             };
             await rebalanceIntentStore.save(intent);
             const result = await tracker.createRebalanceAction({
+                type: 'rebalance_message',
                 intentId: 'intent-1',
                 origin: 1,
                 destination: 2,
@@ -416,12 +778,12 @@ describe('ActionTracker', () => {
                 origin: 1,
                 destination: 2,
                 amount: 100n,
-                fulfilledAmount: 50n,
                 createdAt: Date.now(),
                 updatedAt: Date.now(),
             };
             await rebalanceIntentStore.save(intent);
             await tracker.createRebalanceAction({
+                type: 'rebalance_message',
                 intentId: 'intent-1',
                 origin: 1,
                 destination: 2,
@@ -431,23 +793,22 @@ describe('ActionTracker', () => {
             });
             const updatedIntent = await rebalanceIntentStore.get('intent-1');
             expect(updatedIntent?.status).to.equal('in_progress');
-            expect(updatedIntent?.fulfilledAmount).to.equal(50n); // Should not change
         });
     });
     describe('completeRebalanceAction', () => {
-        it('should mark action as complete and update parent intent fulfilledAmount', async () => {
+        it('should mark action as complete and mark parent intent complete if fully fulfilled', async () => {
             const intent = {
                 id: 'intent-1',
                 status: 'in_progress',
                 origin: 1,
                 destination: 2,
                 amount: 100n,
-                fulfilledAmount: 0n,
                 createdAt: Date.now(),
                 updatedAt: Date.now(),
             };
             const action = {
                 id: 'action-1',
+                type: 'rebalance_message',
                 status: 'in_progress',
                 intentId: 'intent-1',
                 messageId: '0xmsg1',
@@ -462,8 +823,8 @@ describe('ActionTracker', () => {
             await tracker.completeRebalanceAction('action-1');
             const updatedAction = await rebalanceActionStore.get('action-1');
             expect(updatedAction?.status).to.equal('complete');
+            // Intent should be complete (derived from completed action amounts)
             const updatedIntent = await rebalanceIntentStore.get('intent-1');
-            expect(updatedIntent?.fulfilledAmount).to.equal(100n);
             expect(updatedIntent?.status).to.equal('complete');
         });
         it('should throw error when action not found', async () => {
@@ -478,7 +839,6 @@ describe('ActionTracker', () => {
                 origin: 1,
                 destination: 2,
                 amount: 100n,
-                fulfilledAmount: 0n,
                 createdAt: Date.now(),
                 updatedAt: Date.now(),
             };
@@ -492,6 +852,7 @@ describe('ActionTracker', () => {
         it('should mark action as failed', async () => {
             const action = {
                 id: 'action-1',
+                type: 'rebalance_message',
                 status: 'in_progress',
                 intentId: 'intent-1',
                 messageId: '0xmsg1',
@@ -527,7 +888,7 @@ describe('ActionTracker', () => {
             expect(call).to.not.be.null;
             const params = call.args[0];
             expect(params.routersByDomain).to.deep.equal(config.routersByDomain);
-            expect(params.excludeTxSender).to.equal(config.rebalancerAddress);
+            expect(params.excludeTxSenders).to.deep.equal([config.rebalancerAddress]);
         });
     });
     describe('delivery check synchronization', () => {
@@ -560,12 +921,12 @@ describe('ActionTracker', () => {
                 origin: 1,
                 destination: 2,
                 amount: 100n,
-                fulfilledAmount: 0n,
                 createdAt: Date.now(),
                 updatedAt: Date.now(),
             };
             const action = {
                 id: 'action-1',
+                type: 'rebalance_message',
                 status: 'in_progress',
                 intentId: 'intent-1',
                 messageId: '0xmsg1',
@@ -655,13 +1016,13 @@ describe('ActionTracker', () => {
                 origin: 1,
                 destination: 2,
                 amount: 100n,
-                fulfilledAmount: 0n,
                 createdAt: Date.now(),
                 updatedAt: Date.now(),
             };
             const action = {
                 id: 'action-1',
                 status: 'in_progress',
+                type: 'rebalance_message',
                 intentId: 'intent-1',
                 messageId: '0xmsg1',
                 origin: 1,