@humanode-hyperlane/rebalancer 27.2.2 → 1029.1.1

package/src/core/Rebalancer.test.ts

@@ -229,6 +229,53 @@ describe('Rebalancer', () => {
       expect(results[0].success).to.be.false;
     });
 
+    it('should log scaled route amounts using origin local units', async () => {
+      const ctx = createRebalancerTestContext(['ethereum']);
+      ctx.tokensByChainName.ethereum.scale = {
+        numerator: 1,
+        denominator: 1_000_000_000_000,
+      };
+
+      const logger = {
+        child: Sinon.stub(),
+        info: Sinon.stub(),
+        warn: Sinon.stub(),
+        error: Sinon.stub(),
+      };
+      logger.child.returns(logger);
+
+      const rebalancer = new Rebalancer(
+        ctx.warpCore,
+        ctx.chainMetadata,
+        ctx.tokensByChainName,
+        ctx.multiProvider as any,
+        createMockActionTracker(),
+        logger as any,
+      );
+
+      const route = buildTestMovableCollateralRoute({
+        origin: 'ethereum',
+        destination: 'arbitrum',
+        amount: 1_000_000n,
+      });
+      const results = await rebalancer.rebalance([route]);
+
+      expect(results).to.have.lengthOf(1);
+      expect(results[0].success).to.be.false;
+      const validationErrorCall = logger.error
+        .getCalls()
+        .find(
+          (call) =>
+            call.args[1] ===
+            'Route validation failed: destination token not found.',
+        );
+      expect(validationErrorCall).to.not.be.undefined;
+      expect(validationErrorCall!.args[0].amount).to.equal(1);
+      expect(validationErrorCall!.args[1]).to.equal(
+        'Route validation failed: destination token not found.',
+      );
+    });
+
     it('should fail when signer is not a rebalancer', async () => {
       const ctx = createRebalancerTestContext(['ethereum', 'arbitrum'], {
         ethereum: { isRebalancer: false },
@@ -337,6 +384,43 @@ describe('Rebalancer', () => {
       expect(results).to.have.lengthOf(1);
       expect(results[0].success).to.be.false;
     });
+
+    it('should denormalize canonical route amounts before quote and populate calls', async () => {
+      const ctx = createRebalancerTestContext(['ethereum', 'arbitrum']);
+      ctx.tokensByChainName.ethereum.scale = {
+        numerator: 1,
+        denominator: 1_000_000_000_000,
+      };
+
+      sandbox.stub(HyperlaneCore, 'getDispatchedMessages').returns([
+        {
+          id: '0x1111111111111111111111111111111111111111111111111111111111111111',
+        } as any,
+      ]);
+
+      const rebalancer = new Rebalancer(
+        ctx.warpCore,
+        ctx.chainMetadata,
+        ctx.tokensByChainName,
+        ctx.multiProvider as any,
+        createMockActionTracker(),
+        testLogger,
+      );
+
+      await rebalancer.rebalance([
+        buildTestMovableCollateralRoute({
+          amount: 1_000_000n,
+        }),
+      ]);
+
+      expect(ctx.adapters.ethereum.getRebalanceQuotes.calledOnce).to.be.true;
+      expect(
+        ctx.adapters.ethereum.getRebalanceQuotes.firstCall.args[3],
+      ).to.equal(1_000_000_000_000_000_000n);
+      expect(
+        ctx.adapters.ethereum.populateRebalanceTx.firstCall.args[1],
+      ).to.equal(1_000_000_000_000_000_000n);
+    });
   });
 
   describe('executeTransactions()', () => {

package/src/core/Rebalancer.ts

@@ -25,10 +25,16 @@ import { MovableCollateralRoute } from '../interfaces/IStrategy.js';
 import { type Metrics } from '../metrics/Metrics.js';
 import type { IActionTracker } from '../tracking/IActionTracker.js';
 import type { RebalanceIntent } from '../tracking/types.js';
+import {
+  denormalizeToLocal,
+  normalizeToCanonical,
+} from '../utils/balanceUtils.js';
 
 // Internal types with intentId for tracking
 type InternalExecutionResult = MovableCollateralExecutionResult & {
   intentId: string;
+  canonicalAmount?: bigint;
+  localAmount?: bigint;
 };
 
 type InternalRoute = MovableCollateralRoute & { intentId: string };
@@ -104,7 +110,10 @@ export class Rebalancer implements IMovableCollateralRebalancer {
         if (token) {
           this.metrics.recordRebalanceAmount(
             result.route,
-            token.amount(result.route.amount),
+            token.amount(
+              result.localAmount ??
+                denormalizeToLocal(result.route.amount, token),
+            ),
           );
         }
       }
@@ -150,7 +159,7 @@ export class Rebalancer implements IMovableCollateralRebalancer {
           intentId,
           origin: this.multiProvider.getDomainId(result.route.origin),
           destination: this.multiProvider.getDomainId(result.route.destination),
-          amount: result.route.amount,
+          amount: result.canonicalAmount ?? result.route.amount,
           type: 'rebalance_message',
           messageId: result.messageId,
           txHash: result.txHash,
@@ -264,8 +273,9 @@ export class Rebalancer implements IMovableCollateralRebalancer {
     const originToken = this.tokensByChainName[origin];
     const destinationToken = this.tokensByChainName[destination];
     const destinationChainMeta = this.chainMetadata[destination];
+    const localAmount = denormalizeToLocal(amount, originToken);
 
-    const originTokenAmount = originToken.amount(amount);
+    const originTokenAmount = originToken.amount(localAmount);
     const decimalFormattedAmount =
       originTokenAmount.getDecimalFormattedAmount();
     const originHypAdapter = originToken.getHypAdapter(
@@ -281,7 +291,7 @@ export class Rebalancer implements IMovableCollateralRebalancer {
         bridge,
         destinationChainMeta.domainId,
         destinationToken.addressOrDenom,
-        amount,
+        localAmount,
       );
     } catch (error) {
       this.logger.error(
@@ -302,7 +312,7 @@ export class Rebalancer implements IMovableCollateralRebalancer {
     try {
       populatedTx = await originHypAdapter.populateRebalanceTx(
         destinationChainMeta.domainId,
-        amount,
+        localAmount,
         bridge,
         quotes,
       );
@@ -337,7 +347,8 @@ export class Rebalancer implements IMovableCollateralRebalancer {
       return false;
     }
 
-    const originTokenAmount = originToken.amount(amount);
+    const localAmount = denormalizeToLocal(amount, originToken);
+    const originTokenAmount = originToken.amount(localAmount);
     const decimalFormattedAmount =
       originTokenAmount.getDecimalFormattedAmount();
 
@@ -676,6 +687,11 @@ export class Rebalancer implements IMovableCollateralRebalancer {
       success: true,
       messageId: dispatchedMessages[0].id,
       txHash: receipt.transactionHash,
+      canonicalAmount: normalizeToCanonical(
+        transaction.originTokenAmount.amount,
+        transaction.originTokenAmount.token,
+      ),
+      localAmount: transaction.originTokenAmount.amount,
     };
   }
 

package/src/core/RebalancerOrchestrator.test.ts

@@ -646,7 +646,6 @@ describe('RebalancerOrchestrator', () => {
       expect(inventoryRebalancer.rebalance.calledWith([])).to.be.false;
     });
 
-    // eslint-disable-next-line jest/expect-expect
     it('should NOT call inventoryRebalancer.rebalance([]) when inventoryRebalancer is not in rebalancers', async () => {
       const strategy = createMockStrategy();
       strategy.getRebalancingRoutes.returns([]);

package/src/core/RebalancerService.test.ts

@@ -366,6 +366,41 @@ describe('RebalancerService', () => {
       expect(calledRoutes[0].destination).to.equal('arbitrum');
     });
 
+    it('should normalize manual amount to canonical units when token has scale', async () => {
+      const rebalancer = createMockRebalancer();
+      const warpCore = {
+        tokens: [
+          {
+            ...createMockToken('ethereum'),
+            decimals: 18,
+            scale: { numerator: 1n, denominator: 1_000_000_000_000n },
+          },
+          createMockToken('arbitrum'),
+        ],
+        multiProvider: createMockMultiProvider(),
+      } as unknown as WarpCore;
+
+      const contextFactory = createMockContextFactory({ rebalancer, warpCore });
+      sandbox.stub(RebalancerContextFactory, 'create').resolves(contextFactory);
+
+      const service = new RebalancerService(
+        createMockMultiProvider(),
+        undefined,
+        {} as any,
+        createMockRebalancerConfig(),
+        { mode: 'manual', logger: testLogger },
+      );
+
+      await service.executeManual({
+        origin: 'ethereum',
+        destination: 'arbitrum',
+        amount: '1',
+      });
+
+      const calledRoutes = rebalancer.rebalance.firstCall.args[0];
+      expect(calledRoutes[0].amount).to.equal(1_000_000n);
+    });
+
     it('should throw when origin token not found', async () => {
       const warpCore = {
         tokens: [createMockToken('arbitrum')],

package/src/core/RebalancerService.ts

@@ -6,7 +6,7 @@ import {
   type MultiProvider,
   Token,
 } from '@humanode-hyperlane/sdk';
-import { ProtocolType, assert, toWei } from '@humanode-hyperlane/utils';
+import { ProtocolType, assert } from '@humanode-hyperlane/utils';
 
 import { RebalancerConfig } from '../config/RebalancerConfig.js';
 import {
@@ -30,6 +30,7 @@ import { Metrics } from '../metrics/Metrics.js';
 import { type InventoryMonitorConfig, Monitor } from '../monitor/Monitor.js';
 import type { IActionTracker } from '../tracking/IActionTracker.js';
 import { InflightContextAdapter } from '../tracking/InflightContextAdapter.js';
+import { normalizeConfiguredAmount } from '../utils/balanceUtils.js';
 
 import type { RebalancerOrchestrator } from './RebalancerOrchestrator.js';
 
@@ -296,7 +297,7 @@ export class RebalancerService {
       const manualRoute: MovableCollateralRoute & { intentId: string } = {
         origin,
         destination,
-        amount: BigInt(toWei(amount, originToken.decimals)),
+        amount: normalizeConfiguredAmount(amount, originToken),
         executionType: 'movableCollateral',
         bridge,
         intentId: `manual-${Date.now()}`,

package/src/e2e/harness/BaseLocalDeploymentManager.ts

@@ -24,6 +24,8 @@ import {
   TEST_CHAIN_CONFIGS,
 } from '../fixtures/routes.js';
 
+import { createLocalProvider } from './LocalProvider.js';
+
 export interface LocalDeploymentContext<
   TDeployedAddresses extends {
     chains: Record<string, { mailbox: string; ism: string }>;
@@ -94,7 +96,7 @@ export abstract class BaseLocalDeploymentManager<
         );
         this.containers.set(config.name, container);
         const endpoint = `http://${container.getHost()}:${container.getMappedPort(8545)}`;
-        const provider = new providers.JsonRpcProvider(endpoint);
+        const provider = createLocalProvider(endpoint);
         providersByChain.set(config.name, provider);
 
         await provider.send('anvil_setBalance', [

package/src/e2e/harness/LocalProvider.test.ts

@@ -0,0 +1,16 @@
+import { expect } from 'chai';
+
+import { createLocalProvider } from './LocalProvider.js';
+
+describe('createLocalProvider', () => {
+  it('uses fast polling for each fresh local provider', () => {
+    const url = 'http://127.0.0.1:8545';
+    const first = createLocalProvider(url);
+    const replacement = createLocalProvider(url);
+
+    expect(first.pollingInterval).to.equal(100);
+    expect(replacement.pollingInterval).to.equal(100);
+    expect(replacement).not.to.equal(first);
+    expect(replacement.connection.url).to.equal(url);
+  });
+});

package/src/e2e/harness/LocalProvider.ts

@@ -0,0 +1,10 @@
+import { providers } from 'ethers';
+
+// Anvil mines immediately; ethers' 4s default adds idle time to transaction waits.
+const LOCAL_POLLING_INTERVAL_MS = 100;
+
+export function createLocalProvider(url: string): providers.JsonRpcProvider {
+  const provider = new providers.JsonRpcProvider(url);
+  provider.pollingInterval = LOCAL_POLLING_INTERVAL_MS;
+  return provider;
+}

package/src/e2e/harness/NativeLocalDeploymentManager.ts

@@ -115,10 +115,11 @@ export class NativeLocalDeploymentManager extends BaseLocalDeploymentManager<Nat
     for (const chain of TEST_CHAIN_CONFIGS) {
       const provider = providersByChain.get(chain.name)!;
       const deployer = deployerWallet.connect(provider);
-      await deployer.sendTransaction({
+      const seedTx = await deployer.sendTransaction({
         to: bridgeRouters[chain.name].address,
         value: bridgeSeedAmount,
       });
+      await seedTx.wait();
     }
 
     return {

package/src/e2e/harness/SnapshotHelper.ts

@@ -8,10 +8,7 @@ import {
 import { assert, retryAsync } from '@humanode-hyperlane/utils';
 
 import { ANVIL_TEST_PRIVATE_KEY, TEST_CHAINS } from '../fixtures/routes.js';
-
-function createFreshProvider(url: string): providers.JsonRpcProvider {
-  return new providers.JsonRpcProvider(url);
-}
+import { createLocalProvider } from './LocalProvider.js';
 
 /**
  * Revert all chains to their snapshots, take new snapshots, and refresh
@@ -39,7 +36,7 @@ export async function resetSnapshotsAndRefreshProviders({
 
   for (const [chain, oldProvider] of Array.from(localProviders.entries())) {
     const url = oldProvider.connection.url;
-    const freshProvider = createFreshProvider(url);
+    const freshProvider = createLocalProvider(url);
     localProviders.set(chain, freshProvider);
     multiProvider.setProvider(chain, freshProvider);
     multiProvider.setSigner(chain, signerWallet.connect(freshProvider));

package/src/e2e/harness/TestHelpers.ts

@@ -25,9 +25,9 @@ export async function getFirstMonitorEvent(
   return new Promise((resolve, reject) => {
     let settled = false;
 
-    async function finalize(
-      cb: (v: any) => void, // eslint-disable-line @typescript-eslint/no-explicit-any -- accepts both resolve and reject
-      value: unknown,
+    async function finalize<T>(
+      cb: (v: T) => void,
+      value: T,
       timer: ReturnType<typeof setTimeout>,
     ) {
       if (settled) return;

package/src/e2e/harness/TestRebalancer.ts

@@ -18,6 +18,7 @@ import { RebalancerConfig } from '../../config/RebalancerConfig.js';
 import {
   DEFAULT_INTENT_TTL_MS,
   ExternalBridgeType,
+  type PendingTransferMiddlewareConfig,
   type StrategyConfig,
   getStrategyChainNames,
 } from '../../config/types.js';
@@ -112,6 +113,8 @@ export class TestRebalancerBuilder {
   private balanceConfig: BalanceConfig = 'BALANCED';
   private pendingTransfers: PendingTransferParams[] = [];
   private mockTransfers: ExplorerMessage[] = [];
+  private mockRebalanceActions: ExplorerMessage[] = [];
+  private pendingTransferMiddlewares: PendingTransferMiddlewareConfig[] = [];
   private executionMode: ExecutionMode = 'propose';
   private inventoryConfig: TestInventoryConfig | undefined;
   private erc20InventoryConfig: TestErc20InventoryConfig | undefined;
@@ -150,6 +153,18 @@ export class TestRebalancerBuilder {
     return this;
   }
 
+  withMockRebalanceAction(message: ExplorerMessage): this {
+    this.mockRebalanceActions.push(message);
+    return this;
+  }
+
+  withPendingTransferMiddlewares(
+    configs: PendingTransferMiddlewareConfig[],
+  ): this {
+    this.pendingTransferMiddlewares = configs;
+    return this;
+  }
+
   withExecutionMode(mode: ExecutionMode): this {
     this.executionMode = mode;
     return this;
@@ -310,6 +325,7 @@ export class TestRebalancerBuilder {
           },
         },
         { lifi: { integrator: 'test' } },
+        this.pendingTransferMiddlewares,
       );
       warpCoreConfig = buildErc20InventoryWarpRouteConfig(
         erc20InventoryModeConfig.erc20DeployedAddresses,
@@ -330,6 +346,7 @@ export class TestRebalancerBuilder {
           },
         },
         { lifi: { integrator: 'test' } },
+        this.pendingTransferMiddlewares,
       );
       warpCoreConfig = buildNativeWarpRouteConfig(
         inventoryModeConfig.nativeDeployedAddresses,
@@ -342,6 +359,9 @@ export class TestRebalancerBuilder {
         MONITORED_ROUTE_ID,
         this.strategyConfig,
         DEFAULT_INTENT_TTL_MS,
+        undefined,
+        undefined,
+        this.pendingTransferMiddlewares,
       );
       warpCoreConfig = buildWarpRouteConfig(deployedAddresses);
     }
@@ -701,7 +721,7 @@ export class TestRebalancerBuilder {
 
     return {
       userTransfers,
-      rebalanceActions: [],
+      rebalanceActions: [...this.mockRebalanceActions],
     };
   }