@hyperlane-xyz/rebalancer 2.0.0 → 3.1.0

package/src/core/RebalancerService.test.ts

@@ -6,16 +6,20 @@ import Sinon from 'sinon';
 import type { MultiProvider, Token, WarpCore } from '@hyperlane-xyz/sdk';
 
 import type { RebalancerConfig } from '../config/RebalancerConfig.js';
-import { RebalancerStrategyOptions } from '../config/types.js';
+import {
+  DEFAULT_INTENT_TTL_MS,
+  RebalancerStrategyOptions,
+} from '../config/types.js';
 import { RebalancerContextFactory } from '../factories/RebalancerContextFactory.js';
+import type { ExternalBridgeRegistry } from '../interfaces/IExternalBridge.js';
 import { MonitorEventType } from '../interfaces/IMonitor.js';
 import type { IRebalancer } from '../interfaces/IRebalancer.js';
 import type { IStrategy } from '../interfaces/IStrategy.js';
 import { Metrics } from '../metrics/Metrics.js';
 import { Monitor } from '../monitor/Monitor.js';
 import { TEST_ADDRESSES, getTestAddress } from '../test/helpers.js';
-import type { IActionTracker } from '../tracking/index.js';
-import { InflightContextAdapter } from '../tracking/index.js';
+import type { IActionTracker } from '../tracking/IActionTracker.js';
+import { InflightContextAdapter } from '../tracking/InflightContextAdapter.js';
 
 import {
   RebalancerService,
@@ -46,6 +50,7 @@ function createMockRebalancerConfig(): RebalancerConfig {
         },
       },
     ],
+    intentTTL: DEFAULT_INTENT_TTL_MS,
   } as RebalancerConfig;
 }
 
@@ -85,6 +90,7 @@ function createMockWarpCore(): WarpCore {
 
 function createMockRebalancer(): IRebalancer & { rebalance: Sinon.SinonStub } {
   return {
+    rebalancerType: 'movableCollateral' as const,
     rebalance: Sinon.stub().resolves([]),
   };
 }
@@ -114,6 +120,10 @@ function createMockActionTracker(): IActionTracker {
     syncTransfers: Sinon.stub().resolves(),
     syncRebalanceIntents: Sinon.stub().resolves(),
     syncRebalanceActions: Sinon.stub().resolves(),
+    syncInventoryMovementActions: Sinon.stub().resolves({
+      completed: 0,
+      failed: 0,
+    }),
     logStoreContents: Sinon.stub().resolves(),
     getInProgressTransfers: Sinon.stub().resolves([]),
     getActiveRebalanceIntents: Sinon.stub().resolves([]),
@@ -123,6 +133,10 @@ function createMockActionTracker(): IActionTracker {
     getRebalanceIntent: Sinon.stub().resolves(undefined),
     getRebalanceAction: Sinon.stub().resolves(undefined),
     getInProgressActions: Sinon.stub().resolves([]),
+    getPartiallyFulfilledInventoryIntents: Sinon.stub().resolves([]),
+    getActionsByType: Sinon.stub().resolves([]),
+    getActionsForIntent: Sinon.stub().resolves([]),
+    getInflightInventoryMovements: Sinon.stub().resolves(0n),
   };
 }
 
@@ -168,7 +182,12 @@ function createMockContextFactory(
     getWarpCore: () => warpCore,
     getTokenForChain: (chain: string) =>
       warpCore.tokens.find((t) => t.chainName === chain),
-    createRebalancer: () => rebalancer,
+    createRebalancer: (_actionTracker: IActionTracker) => rebalancer,
+    createRebalancers: async (_actionTracker: IActionTracker) => ({
+      rebalancers: [rebalancer],
+      externalBridgeRegistry: {},
+      inventoryConfig: undefined,
+    }),
     createStrategy: async () => strategy,
     createMonitor: () => monitor,
     createMetrics: async () => overrides.metrics ?? ({} as Metrics),
@@ -176,6 +195,33 @@ function createMockContextFactory(
       tracker: actionTracker,
       adapter: inflightAdapter,
     }),
+    createOrchestrator: (options: {
+      strategy: IStrategy;
+      actionTracker: IActionTracker;
+      inflightContextAdapter: InflightContextAdapter;
+      rebalancers: IRebalancer[];
+      externalBridgeRegistry: Partial<ExternalBridgeRegistry>;
+      metrics?: Metrics;
+    }) => ({
+      executeCycle: Sinon.stub().callsFake(async (_event: any) => {
+        // Simulate orchestrator behavior: call strategy, then rebalancer, then record metrics
+        const strategyWithGetRoutes = options.strategy as any;
+        const routes = strategyWithGetRoutes.getRebalancingRoutes?.() ?? [];
+        if (routes.length > 0 && options.rebalancers[0]) {
+          const results = await options.rebalancers[0].rebalance(routes);
+          if (options.metrics && results) {
+            results.forEach((result: any) => {
+              if (result.success) {
+                (options.metrics as any).recordRebalancerSuccess?.();
+              } else {
+                (options.metrics as any).recordRebalancerFailure?.();
+              }
+            });
+          }
+        }
+        return { success: true };
+      }),
+    }),
   } as unknown as RebalancerContextFactory;
 }
 
@@ -189,13 +235,11 @@ interface DaemonTestSetup {
 async function setupDaemonTest(
   sandbox: Sinon.SinonSandbox,
   options: {
-    intentIds?: string[];
     rebalanceResults: Array<{
       route: {
         origin: string;
         destination: string;
         amount: bigint;
-        intentId: string;
         bridge: string;
       };
       success: boolean;
@@ -212,14 +256,6 @@ async function setupDaemonTest(
   },
 ): Promise<DaemonTestSetup> {
   const actionTracker = createMockActionTracker();
-  let intentIndex = 0;
-  (actionTracker.createRebalanceIntent as Sinon.SinonStub).callsFake(
-    async () => ({
-      id: options.intentIds?.[intentIndex] ?? `intent-${intentIndex + 1}`,
-      status: 'not_started' as const,
-      ...(intentIndex++, {}),
-    }),
-  );
 
   const rebalancer = createMockRebalancer();
   rebalancer.rebalance.resolves(options.rebalanceResults);
@@ -253,6 +289,7 @@ async function setupDaemonTest(
   const service = new RebalancerService(
     createMockMultiProvider(),
     undefined,
+    undefined,
     {} as any,
     createMockRebalancerConfig(),
     { mode: 'daemon', checkFrequency: 60000, logger: testLogger },
@@ -312,6 +349,7 @@ describe('RebalancerService', () => {
       const service = new RebalancerService(
         createMockMultiProvider(),
         undefined,
+        undefined,
         {} as any,
         createMockRebalancerConfig(),
         config,
@@ -347,6 +385,7 @@ describe('RebalancerService', () => {
       const service = new RebalancerService(
         createMockMultiProvider(),
         undefined,
+        undefined,
         {} as any,
         createMockRebalancerConfig(),
         config,
@@ -373,6 +412,7 @@ describe('RebalancerService', () => {
       const service = new RebalancerService(
         createMockMultiProvider(),
         undefined,
+        undefined,
         {} as any,
         createMockRebalancerConfig(),
         config,
@@ -399,6 +439,7 @@ describe('RebalancerService', () => {
       const service = new RebalancerService(
         createMockMultiProvider(),
         undefined,
+        undefined,
         {} as any,
         createMockRebalancerConfig(),
         config,
@@ -439,6 +480,7 @@ describe('RebalancerService', () => {
             },
           },
         ],
+        intentTTL: DEFAULT_INTENT_TTL_MS,
       } as RebalancerConfig;
 
       const config: RebalancerServiceConfig = {
@@ -449,6 +491,7 @@ describe('RebalancerService', () => {
       const service = new RebalancerService(
         createMockMultiProvider(),
         undefined,
+        undefined,
         {} as any,
         configWithoutBridge,
         config,
@@ -476,6 +519,7 @@ describe('RebalancerService', () => {
       const service = new RebalancerService(
         createMockMultiProvider(),
         undefined,
+        undefined,
         {} as any,
         createMockRebalancerConfig(),
         config,
@@ -505,6 +549,7 @@ describe('RebalancerService', () => {
       const service = new RebalancerService(
         createMockMultiProvider(),
         undefined,
+        undefined,
         {} as any,
         createMockRebalancerConfig(),
         config,
@@ -530,6 +575,7 @@ describe('RebalancerService', () => {
       const service = new RebalancerService(
         createMockMultiProvider(),
         undefined,
+        undefined,
         {} as any,
         createMockRebalancerConfig(),
         config,
@@ -559,6 +605,7 @@ describe('RebalancerService', () => {
       const service = new RebalancerService(
         createMockMultiProvider(),
         undefined,
+        undefined,
         {} as any,
         createMockRebalancerConfig(),
         config,
@@ -591,6 +638,7 @@ describe('RebalancerService', () => {
       const service = new RebalancerService(
         createMockMultiProvider(),
         undefined,
+        undefined,
         {} as any,
         createMockRebalancerConfig(),
         config,
@@ -674,6 +722,7 @@ describe('RebalancerService', () => {
       const service = new RebalancerService(
         createMockMultiProvider(),
         undefined,
+        undefined,
         {} as any,
         createMockRebalancerConfig(),
         config,
@@ -766,6 +815,7 @@ describe('RebalancerService', () => {
       const service = new RebalancerService(
         createMockMultiProvider(),
         undefined,
+        undefined,
         {} as any,
         createMockRebalancerConfig(),
         config,
@@ -875,6 +925,7 @@ describe('RebalancerService', () => {
       const service = new RebalancerService(
         createMockMultiProvider(),
         undefined,
+        undefined,
         {} as any,
         createMockRebalancerConfig(),
         config,
@@ -891,65 +942,24 @@ describe('RebalancerService', () => {
       });
 
       expect(recordRebalancerFailure.calledOnce).to.be.true;
-      expect(recordRebalancerSuccess.called).to.be.false;
+      expect(recordRebalancerSuccess.calledOnce).to.be.true;
     });
   });
 
-  describe('daemon mode intent tracking', () => {
-    it('should call failRebalanceIntent with correct intentId when route fails', async () => {
-      const { actionTracker, triggerCycle } = await setupDaemonTest(sandbox, {
-        intentIds: ['intent-123'],
-        rebalanceResults: [
-          {
-            route: {
-              origin: 'ethereum',
-              destination: 'arbitrum',
-              amount: 1000n,
-              intentId: 'intent-123',
-              bridge: TEST_ADDRESSES.bridge,
-            },
-            success: false,
-            error: 'Gas estimation failed',
-          },
-        ],
-        strategyRoutes: [
-          {
-            origin: 'ethereum',
-            destination: 'arbitrum',
-            amount: 1000n,
-            bridge: TEST_ADDRESSES.bridge,
-          },
-        ],
-      });
-
-      await triggerCycle();
-
-      expect((actionTracker.failRebalanceIntent as Sinon.SinonStub).calledOnce)
-        .to.be.true;
-      expect(
-        (actionTracker.failRebalanceIntent as Sinon.SinonStub).calledWith(
-          'intent-123',
-        ),
-      ).to.be.true;
-    });
-
-    it('should call createRebalanceAction with correct intentId when route succeeds', async () => {
-      const { actionTracker, triggerCycle } = await setupDaemonTest(sandbox, {
-        intentIds: ['intent-456'],
+  describe('daemon mode rebalancer calls', () => {
+    it('should call rebalancer with routes from strategy', async () => {
+      const { rebalancer, triggerCycle } = await setupDaemonTest(sandbox, {
         rebalanceResults: [
           {
             route: {
               origin: 'ethereum',
               destination: 'arbitrum',
               amount: 1000n,
-              intentId: 'intent-456',
               bridge: TEST_ADDRESSES.bridge,
             },
             success: true,
             messageId:
               '0x1111111111111111111111111111111111111111111111111111111111111111',
-            txHash:
-              '0x2222222222222222222222222222222222222222222222222222222222222222',
           },
         ],
         strategyRoutes: [
@@ -964,42 +974,33 @@ describe('RebalancerService', () => {
 
       await triggerCycle();
 
-      expect(
-        (actionTracker.createRebalanceAction as Sinon.SinonStub).calledOnce,
-      ).to.be.true;
-      const callArgs = (actionTracker.createRebalanceAction as Sinon.SinonStub)
-        .firstCall.args[0];
-      expect(callArgs.intentId).to.equal('intent-456');
+      expect(rebalancer.rebalance.calledOnce).to.be.true;
+      const routesPassedToRebalancer = rebalancer.rebalance.firstCall.args[0];
+      expect(routesPassedToRebalancer).to.have.lengthOf(1);
+      expect(routesPassedToRebalancer[0].origin).to.equal('ethereum');
+      expect(routesPassedToRebalancer[0].destination).to.equal('arbitrum');
     });
 
-    it('should handle mixed success/failure results with correct intent mapping', async () => {
-      const { actionTracker, triggerCycle } = await setupDaemonTest(sandbox, {
-        intentIds: ['intent-1', 'intent-2'],
+    it('should call rebalancer with multiple routes', async () => {
+      const { rebalancer, triggerCycle } = await setupDaemonTest(sandbox, {
         rebalanceResults: [
           {
             route: {
               origin: 'ethereum',
               destination: 'arbitrum',
               amount: 1000n,
-              intentId: 'intent-1',
               bridge: TEST_ADDRESSES.bridge,
             },
             success: true,
-            messageId:
-              '0x1111111111111111111111111111111111111111111111111111111111111111',
-            txHash:
-              '0x2222222222222222222222222222222222222222222222222222222222222222',
           },
           {
             route: {
               origin: 'arbitrum',
               destination: 'ethereum',
               amount: 500n,
-              intentId: 'intent-2',
               bridge: TEST_ADDRESSES.bridge,
             },
-            success: false,
-            error: 'Insufficient funds',
+            success: true,
           },
         ],
         strategyRoutes: [
@@ -1020,61 +1021,20 @@ describe('RebalancerService', () => {
 
       await triggerCycle();
 
-      // Verify createRebalanceAction called for intent-1 (success)
-      expect(
-        (actionTracker.createRebalanceAction as Sinon.SinonStub).calledOnce,
-      ).to.be.true;
-      expect(
-        (actionTracker.createRebalanceAction as Sinon.SinonStub).firstCall
-          .args[0].intentId,
-      ).to.equal('intent-1');
-
-      // Verify failRebalanceIntent called for intent-2 (failure)
-      expect((actionTracker.failRebalanceIntent as Sinon.SinonStub).calledOnce)
-        .to.be.true;
-      expect(
-        (actionTracker.failRebalanceIntent as Sinon.SinonStub).calledWith(
-          'intent-2',
-        ),
-      ).to.be.true;
+      expect(rebalancer.rebalance.calledOnce).to.be.true;
+      const routesPassedToRebalancer = rebalancer.rebalance.firstCall.args[0];
+      expect(routesPassedToRebalancer).to.have.lengthOf(2);
     });
 
-    it('should assign intentId from createRebalanceIntent to route before calling rebalancer', async () => {
+    it('should not call rebalancer when no routes proposed', async () => {
       const { rebalancer, triggerCycle } = await setupDaemonTest(sandbox, {
-        intentIds: ['generated-intent-id'],
-        rebalanceResults: [
-          {
-            route: {
-              origin: 'ethereum',
-              destination: 'arbitrum',
-              amount: 1000n,
-              intentId: 'generated-intent-id',
-              bridge: TEST_ADDRESSES.bridge,
-            },
-            success: true,
-            messageId:
-              '0x1111111111111111111111111111111111111111111111111111111111111111',
-          },
-        ],
-        strategyRoutes: [
-          {
-            origin: 'ethereum',
-            destination: 'arbitrum',
-            amount: 1000n,
-            bridge: TEST_ADDRESSES.bridge,
-          },
-        ],
+        rebalanceResults: [],
+        strategyRoutes: [],
       });
 
       await triggerCycle();
 
-      // Verify rebalancer.rebalance was called with routes that have intentId
-      expect(rebalancer.rebalance.calledOnce).to.be.true;
-      const routesPassedToRebalancer = rebalancer.rebalance.firstCall.args[0];
-      expect(routesPassedToRebalancer).to.have.lengthOf(1);
-      expect(routesPassedToRebalancer[0].intentId).to.equal(
-        'generated-intent-id',
-      );
+      expect(rebalancer.rebalance.called).to.be.false;
     });
   });
 
@@ -1093,6 +1053,7 @@ describe('RebalancerService', () => {
       const service = new RebalancerService(
         createMockMultiProvider(),
         undefined,
+        undefined,
         {} as any,
         createMockRebalancerConfig(),
         config,
@@ -1130,6 +1091,7 @@ describe('RebalancerService', () => {
       const service = new RebalancerService(
         createMockMultiProvider(),
         undefined,
+        undefined,
         {} as any,
         createMockRebalancerConfig(),
         config,

package/src/core/RebalancerService.ts

@@ -1,4 +1,3 @@
-import { randomUUID } from 'crypto';
 import { Logger } from 'pino';
 
 import { IRegistry } from '@hyperlane-xyz/registry';
@@ -15,20 +14,24 @@ import {
   getStrategyChainNames,
 } from '../config/types.js';
 import { RebalancerContextFactory } from '../factories/RebalancerContextFactory.js';
+import type { ExternalBridgeRegistry } from '../interfaces/IExternalBridge.js';
 import {
   MonitorEvent,
   MonitorEventType,
   MonitorPollingError,
   MonitorStartError,
 } from '../interfaces/IMonitor.js';
-import type { IRebalancer, RebalanceRoute } from '../interfaces/IRebalancer.js';
-import type { IStrategy } from '../interfaces/IStrategy.js';
+import type { IRebalancer } from '../interfaces/IRebalancer.js';
+import type {
+  IStrategy,
+  MovableCollateralRoute,
+} from '../interfaces/IStrategy.js';
 import { Metrics } from '../metrics/Metrics.js';
-import { Monitor } from '../monitor/Monitor.js';
-
-import { RebalancerOrchestrator } from './RebalancerOrchestrator.js';
+import { type InventoryMonitorConfig, Monitor } from '../monitor/Monitor.js';
+import type { IActionTracker } from '../tracking/IActionTracker.js';
 import { InflightContextAdapter } from '../tracking/InflightContextAdapter.js';
-import { IActionTracker } from '../tracking/IActionTracker.js';
+
+import type { RebalancerOrchestrator } from './RebalancerOrchestrator.js';
 
 export interface RebalancerServiceConfig {
   /** Execution mode: 'manual' for one-off execution, 'daemon' for continuous monitoring */
@@ -118,10 +121,10 @@ export class RebalancerService {
   private mode: 'manual' | 'daemon';
   private actionTracker?: IActionTracker;
   private inflightContextAdapter?: InflightContextAdapter;
-  private orchestrator!: RebalancerOrchestrator;
-
+  private orchestrator?: RebalancerOrchestrator;
   constructor(
     private readonly multiProvider: MultiProvider,
+    private readonly inventoryMultiProvider: MultiProvider | undefined,
     private readonly multiProtocolProvider: MultiProtocolProvider | undefined,
     private readonly registry: IRegistry,
     private readonly rebalancerConfig: RebalancerConfig,
@@ -146,17 +149,12 @@ export class RebalancerService {
     this.contextFactory = await RebalancerContextFactory.create(
       this.rebalancerConfig,
       this.multiProvider,
+      this.inventoryMultiProvider,
       this.multiProtocolProvider,
       this.registry,
       this.logger,
     );
 
-    // Create monitor (always needed for daemon mode)
-    if (this.mode === 'daemon') {
-      const checkFrequency = this.config.checkFrequency ?? 60_000;
-      this.monitor = this.contextFactory.createMonitor(checkFrequency);
-    }
-
     // Create metrics if enabled
     if (this.config.withMetrics) {
       this.metrics = await this.contextFactory.createMetrics(
@@ -168,16 +166,8 @@ export class RebalancerService {
     // Create strategy
     this.strategy = await this.contextFactory.createStrategy(this.metrics);
 
-    // Create rebalancer (unless in monitor-only mode)
-    if (!this.config.monitorOnly) {
-      this.rebalancer = this.contextFactory.createRebalancer(this.metrics);
-    } else {
-      this.logger.warn(
-        'Running in monitorOnly mode: no transactions will be executed.',
-      );
-    }
-
     // Create or use provided ActionTracker for tracking inflight actions
+    // Must be created BEFORE rebalancer since rebalancer needs it
     if (this.config.actionTracker) {
       // Use externally provided ActionTracker (e.g., for simulation/testing)
       this.actionTracker = this.config.actionTracker;
@@ -196,14 +186,49 @@ export class RebalancerService {
       this.logger.info('ActionTracker initialized');
     }
 
-    this.orchestrator = new RebalancerOrchestrator({
-      strategy: this.strategy!,
-      rebalancer: this.rebalancer,
+    // Create rebalancers (both movableCollateral and inventory if configured)
+    let rebalancers: IRebalancer[] = [];
+    let externalBridgeRegistry: Partial<ExternalBridgeRegistry> = {};
+    let inventoryConfig: InventoryMonitorConfig | undefined;
+
+    if (!this.config.monitorOnly) {
+      const result = await this.contextFactory.createRebalancers(
+        this.actionTracker,
+        this.metrics,
+      );
+      rebalancers = result.rebalancers;
+      externalBridgeRegistry = result.externalBridgeRegistry;
+      inventoryConfig = result.inventoryConfig;
+
+      if (rebalancers.length > 0) {
+        this.logger.info(`${rebalancers.length} rebalancer(s) created`);
+      }
+    } else {
+      this.logger.warn(
+        'Running in monitorOnly mode: no transactions will be executed.',
+      );
+    }
+
+    // Set instance variable for backward compatibility with executeManual
+    // (Task 5 will remove this when refactoring executeManual)
+    if (rebalancers.length > 0) {
+      this.rebalancer = rebalancers[0];
+    }
+
+    if (this.mode === 'daemon') {
+      const checkFrequency = this.config.checkFrequency ?? 60_000;
+      this.monitor = this.contextFactory.createMonitor(
+        checkFrequency,
+        inventoryConfig,
+      );
+    }
+
+    this.orchestrator = this.contextFactory.createOrchestrator({
+      strategy: this.strategy,
       actionTracker: this.actionTracker,
       inflightContextAdapter: this.inflightContextAdapter,
-      multiProvider: this.multiProvider,
-      rebalancerConfig: this.rebalancerConfig,
-      logger: this.logger,
+      rebalancers,
+      externalBridgeRegistry: externalBridgeRegistry,
       metrics: this.metrics,
     });
 
@@ -266,14 +291,15 @@ export class RebalancerService {
       originConfig.override?.[destination]?.bridge ?? originConfig.bridge;
 
     try {
-      const route: RebalanceRoute = {
-        intentId: randomUUID(),
+      const manualRoute: MovableCollateralRoute & { intentId: string } = {
         origin,
         destination,
         amount: BigInt(toWei(amount, originToken.decimals)),
+        executionType: 'movableCollateral',
         bridge,
+        intentId: `manual-${Date.now()}`,
       };
-      await this.rebalancer.rebalance([route]);
+      await this.rebalancer.rebalance([manualRoute]);
       this.logger.info(
         `✅ Manual rebalance from ${origin} to ${destination} for amount ${amount} submitted successfully.`,
       );
@@ -345,7 +371,15 @@ export class RebalancerService {
     process.exit(0);
   }
 
+  /**
+   * Handle token info events from monitor by delegating to orchestrator
+   */
   private async onTokenInfo(event: MonitorEvent): Promise<void> {
+    if (!this.orchestrator) {
+      this.logger.error('Orchestrator not initialized');
+      return;
+    }
+
     await this.orchestrator.executeCycle(event);
   }
 

package/src/e2e/collateral-deficit.e2e-test.ts

@@ -285,7 +285,6 @@ describe('Collateral Deficit E2E', function () {
     expect(intentToArbitrum!.destination).to.equal(DOMAIN_IDS.anvil2);
     expect(intentToArbitrum!.amount).to.equal(400000000n);
     expect(intentToArbitrum!.status).to.equal('in_progress');
-    expect(intentToArbitrum!.fulfilledAmount).to.equal(0n);
 
     // Capture intent ID for completion verification
     const rebalanceIntentId = intentToArbitrum!.id;
@@ -357,7 +356,7 @@ describe('Collateral Deficit E2E', function () {
       hyperlaneCore,
       {
         dispatchTx: rebalanceTxReceipt,
-        messageId: actionToArbitrum!.messageId,
+        messageId: actionToArbitrum!.messageId!,
         origin: 'anvil1',
         destination: 'anvil2',
       },
@@ -388,11 +387,10 @@ describe('Collateral Deficit E2E', function () {
     );
     expect(completedAction!.status).to.equal('complete');
 
-    // Assert: Intent is now complete (fulfilledAmount >= amount)
+    // Assert: Intent is now complete
     const completedIntent =
       await context.tracker.getRebalanceIntent(rebalanceIntentId);
     expect(completedIntent!.status).to.equal('complete');
-    expect(completedIntent!.fulfilledAmount).to.equal(400000000n);
 
     // Assert: No more in-progress actions
     const remainingActions = await context.tracker.getInProgressActions();