@humanode-hyperlane/rebalancer 27.2.2 → 1029.1.1

package/src/service.ts

@@ -1,4 +1,6 @@
 #!/usr/bin/env node
+import 'zod/compile';
+
 /**
  * Hyperlane Rebalancer Service Entry Point
  *
@@ -33,6 +35,7 @@ import { MultiProvider } from '@humanode-hyperlane/sdk';
 import {
   applyRpcUrlOverridesFromEnv,
   createServiceLogger,
+  isEVMLike,
   ProtocolType,
   rootLogger,
 } from '@humanode-hyperlane/utils';
@@ -151,12 +154,15 @@ async function main(): Promise<void> {
       Record<ProtocolType, InventorySignerConfig>
     > = {};
 
-    for (const [protocol, privateKey] of Object.entries(inventoryPrivateKeys)) {
+    for (const protocol of Object.values(ProtocolType)) {
+      const privateKey = inventoryPrivateKeys[protocol];
       if (!privateKey) continue;
 
       let derivedAddress: string;
 
-      if (protocol === ProtocolType.Ethereum) {
+      if (isEVMLike(protocol)) {
+        // Tron uses same hex private key format as Ethereum.
+        // Derive 0x-prefixed hex address via ethers Wallet (TronWallet extends Wallet).
         derivedAddress = new Wallet(privateKey).address;
       } else if (protocol === ProtocolType.Sealevel) {
         const keyBytes = parseSolanaPrivateKey(privateKey);
@@ -172,12 +178,11 @@ async function main(): Promise<void> {
 
       // Validate against config if present
       const configuredAddress =
-        rebalancerConfig.inventorySigners?.[protocol as ProtocolType]?.address;
+        rebalancerConfig.inventorySigners?.[protocol]?.address;
       if (configuredAddress) {
-        const mismatch =
-          protocol === ProtocolType.Ethereum
-            ? configuredAddress.toLowerCase() !== derivedAddress.toLowerCase()
-            : configuredAddress !== derivedAddress;
+        const mismatch = isEVMLike(protocol)
+          ? configuredAddress.toLowerCase() !== derivedAddress.toLowerCase()
+          : configuredAddress !== derivedAddress;
         if (mismatch) {
           throw new Error(
             `inventorySigners.${protocol} mismatch: config has ${configuredAddress} but HYP_INVENTORY_KEY_${protocol.toUpperCase()} derives to ${derivedAddress}`,
@@ -185,7 +190,7 @@ async function main(): Promise<void> {
         }
       }
 
-      inventorySigners[protocol as ProtocolType] = {
+      inventorySigners[protocol] = {
         address: derivedAddress,
         key: privateKey,
       };
@@ -242,6 +247,7 @@ async function main(): Promise<void> {
             rebalancerConfig.intentTTL,
             mergedInventorySigners,
             rebalancerConfig.externalBridges,
+            rebalancerConfig.pendingTransferMiddlewares,
           )
         : rebalancerConfig;
 

package/src/strategy/BaseStrategy.ts

@@ -1,7 +1,6 @@
 import { type Logger } from 'pino';
 
 import type { ChainMap, ChainName, Token } from '@humanode-hyperlane/sdk';
-import { toWei } from '@humanode-hyperlane/utils';
 
 import type {
   IStrategy,
@@ -18,6 +17,7 @@ import {
   createStrategyRoute,
   getBridgeConfig,
 } from '../utils/bridgeUtils.js';
+import { normalizeConfiguredAmount } from '../utils/balanceUtils.js';
 
 export type Delta = { chain: ChainName; amount: bigint };
 
@@ -528,21 +528,24 @@ export abstract class BaseStrategy implements IStrategy {
             route.origin,
             route.destination,
           );
-          const minAmount = BigInt(
-            toWei(bridgeConfig.bridgeMinAcceptedAmount, token.decimals),
-          );
-          if (route.amount < minAmount) {
-            this.logger.info(
-              {
-                context: this.constructor.name,
-                origin: route.origin,
-                destination: route.destination,
-                amount: route.amount.toString(),
-                minAmount: minAmount.toString(),
-              },
-              'Dropping route below bridgeMinAcceptedAmount',
+          if (bridgeConfig.bridgeMinAcceptedAmount != null) {
+            const minAmount = normalizeConfiguredAmount(
+              bridgeConfig.bridgeMinAcceptedAmount,
+              token,
             );
-            return false;
+            if (route.amount < minAmount) {
+              this.logger.info(
+                {
+                  context: this.constructor.name,
+                  origin: route.origin,
+                  destination: route.destination,
+                  amount: route.amount.toString(),
+                  minAmount: minAmount.toString(),
+                },
+                'Dropping route below bridgeMinAcceptedAmount',
+              );
+              return false;
+            }
           }
         }
       }

package/src/strategy/CollateralDeficitStrategy.ts

@@ -5,7 +5,6 @@ import {
   type ChainName,
   type Token,
 } from '@humanode-hyperlane/sdk';
-import { toWei } from '@humanode-hyperlane/utils';
 
 import {
   type CollateralDeficitStrategyConfig,
@@ -24,6 +23,7 @@ import {
   isInventoryConfig,
   isMovableCollateralConfig,
 } from '../utils/bridgeUtils.js';
+import { normalizeConfiguredAmount } from '../utils/balanceUtils.js';
 
 import { BaseStrategy, type Delta } from './BaseStrategy.js';
 
@@ -106,8 +106,9 @@ export class CollateralDeficitStrategy extends BaseStrategy {
     for (const chain of this.chains) {
       const balance = simulatedBalances[chain];
       const token = this.getTokenByChainName(chain);
-      const bufferWei = BigInt(
-        toWei(this.config[chain].buffer, token.decimals),
+      const bufferWei = normalizeConfiguredAmount(
+        this.config[chain].buffer,
+        token,
       );
 
       if (balance < 0n) {

package/src/strategy/MinAmountStrategy.test.ts

@@ -10,8 +10,10 @@ import {
 } from '@humanode-hyperlane/sdk';
 
 import { RebalancerMinAmountType } from '../config/types.js';
+import { type MonitorEvent } from '../interfaces/IMonitor.js';
 import type { RawBalances } from '../interfaces/IStrategy.js';
 import { extractBridgeConfigs } from '../test/helpers.js';
+import { getRawBalances } from '../utils/balanceUtils.js';
 
 import { MinAmountStrategy } from './MinAmountStrategy.js';
 
@@ -64,7 +66,6 @@ describe('MinAmountStrategy', () => {
       ).to.throw('At least two chains must be configured');
     });
 
-    // eslint-disable-next-line jest/expect-expect -- testing constructor doesn't throw
     it('should create a strategy with minAmount and target using absolute values', () => {
       new MinAmountStrategy(
         {
@@ -94,7 +95,6 @@ describe('MinAmountStrategy', () => {
       );
     });
 
-    // eslint-disable-next-line jest/expect-expect -- testing constructor doesn't throw
     it('should create a strategy with minAmount and target using relative values', () => {
       new MinAmountStrategy(
         {
@@ -415,6 +415,146 @@ describe('MinAmountStrategy', () => {
       ]);
     });
 
+    it('should normalize absolute thresholds for mixed-decimal routes', () => {
+      const mixedTokensByChainName: ChainMap<Token> = {
+        [chain1]: new Token({
+          ...tokenArgs,
+          chainName: chain1,
+          decimals: 18,
+          scale: { numerator: 1, denominator: 1_000_000_000_000 },
+        }),
+        [chain2]: new Token({
+          ...tokenArgs,
+          chainName: chain2,
+          decimals: 6,
+        }),
+      };
+      const config = {
+        [chain1]: {
+          minAmount: {
+            min: '100',
+            target: '120',
+            type: RebalancerMinAmountType.Absolute,
+          },
+          bridge: AddressZero,
+          bridgeLockTime: 1,
+        },
+        [chain2]: {
+          minAmount: {
+            min: '100',
+            target: '120',
+            type: RebalancerMinAmountType.Absolute,
+          },
+          bridge: AddressZero,
+          bridgeLockTime: 1,
+        },
+      };
+
+      const strategy = new MinAmountStrategy(
+        config,
+        mixedTokensByChainName,
+        250_000_000n,
+        testLogger,
+        extractBridgeConfigs(config),
+      );
+
+      const routes = strategy.getRebalancingRoutes({
+        [chain1]: 50_000_000n,
+        [chain2]: 200_000_000n,
+      });
+
+      expect(routes).to.deep.equal([
+        {
+          origin: chain2,
+          destination: chain1,
+          amount: 70_000_000n,
+          bridge: AddressZero,
+          executionType: 'movableCollateral',
+        },
+      ]);
+    });
+
+    it('normalizes mixed-decimal local balances before routing', () => {
+      const mixedTokensByChainName: ChainMap<Token> = {
+        [chain1]: new Token({
+          ...tokenArgs,
+          chainName: chain1,
+          standard: TokenStandard.EvmHypCollateral,
+          decimals: 18,
+          scale: { numerator: 1, denominator: 1_000_000_000_000 },
+        }),
+        [chain2]: new Token({
+          ...tokenArgs,
+          chainName: chain2,
+          standard: TokenStandard.EvmHypCollateral,
+          decimals: 6,
+        }),
+      };
+      const config = {
+        [chain1]: {
+          minAmount: {
+            min: '100',
+            target: '120',
+            type: RebalancerMinAmountType.Absolute,
+          },
+          bridge: AddressZero,
+          bridgeLockTime: 1,
+        },
+        [chain2]: {
+          minAmount: {
+            min: '100',
+            target: '120',
+            type: RebalancerMinAmountType.Absolute,
+          },
+          bridge: AddressZero,
+          bridgeLockTime: 1,
+        },
+      };
+
+      const strategy = new MinAmountStrategy(
+        config,
+        mixedTokensByChainName,
+        250_000_000n,
+        testLogger,
+        extractBridgeConfigs(config),
+      );
+
+      const event: MonitorEvent = {
+        tokensInfo: [
+          {
+            token: mixedTokensByChainName[chain1],
+            bridgedSupply: 50_000_000_000_000_000_000n,
+          },
+          {
+            token: mixedTokensByChainName[chain2],
+            bridgedSupply: 200_000_000n,
+          },
+        ],
+        confirmedBlockTags: {
+          [chain1]: 1,
+          [chain2]: 1,
+        },
+      };
+
+      const rawBalances = getRawBalances([chain1, chain2], event, testLogger);
+      expect(rawBalances).to.deep.equal({
+        [chain1]: 50_000_000n,
+        [chain2]: 200_000_000n,
+      });
+
+      const routes = strategy.getRebalancingRoutes(rawBalances);
+
+      expect(routes).to.deep.equal([
+        {
+          origin: chain2,
+          destination: chain1,
+          amount: 70_000_000n,
+          bridge: AddressZero,
+          executionType: 'movableCollateral',
+        },
+      ]);
+    });
+
     it('should return multiple routes for multiple chains below minimum amount', () => {
       const config = {
         [chain1]: {
@@ -514,6 +654,102 @@ describe('MinAmountStrategy', () => {
       );
     });
 
+    it('should keep minAmount validation errors human-readable for mixed-decimal routes', () => {
+      const mixedTokensByChainName: ChainMap<Token> = {
+        [chain1]: new Token({
+          ...tokenArgs,
+          chainName: chain1,
+          decimals: 18,
+          scale: { numerator: 1, denominator: 1_000_000_000_000 },
+        }),
+        [chain2]: new Token({
+          ...tokenArgs,
+          chainName: chain2,
+          decimals: 6,
+        }),
+      };
+
+      expect(
+        () =>
+          new MinAmountStrategy(
+            {
+              [chain1]: {
+                minAmount: {
+                  min: '100',
+                  target: '120',
+                  type: RebalancerMinAmountType.Absolute,
+                },
+                bridge: AddressZero,
+                bridgeLockTime: 1,
+              },
+              [chain2]: {
+                minAmount: {
+                  min: '100',
+                  target: '120',
+                  type: RebalancerMinAmountType.Absolute,
+                },
+                bridge: AddressZero,
+                bridgeLockTime: 1,
+              },
+            },
+            mixedTokensByChainName,
+            230_000_000n,
+            testLogger,
+            {},
+          ),
+      ).to.throw(
+        `Consider reducing the targets as the sum (240) is greater than sum of collaterals (230)`,
+      );
+    });
+
+    it('should keep fractional minAmount validation errors human-readable across heterogeneous decimals', () => {
+      const mixedTokensByChainName: ChainMap<Token> = {
+        [chain1]: new Token({
+          ...tokenArgs,
+          chainName: chain1,
+          decimals: 6,
+        }),
+        [chain2]: new Token({
+          ...tokenArgs,
+          chainName: chain2,
+          decimals: 18,
+          scale: { numerator: 1, denominator: 1_000_000_000_000 },
+        }),
+      };
+
+      expect(
+        () =>
+          new MinAmountStrategy(
+            {
+              [chain1]: {
+                minAmount: {
+                  min: '100',
+                  target: '120.25',
+                  type: RebalancerMinAmountType.Absolute,
+                },
+                bridge: AddressZero,
+                bridgeLockTime: 1,
+              },
+              [chain2]: {
+                minAmount: {
+                  min: '100',
+                  target: '120.25',
+                  type: RebalancerMinAmountType.Absolute,
+                },
+                bridge: AddressZero,
+                bridgeLockTime: 1,
+              },
+            },
+            mixedTokensByChainName,
+            230_500_000n,
+            testLogger,
+            {},
+          ),
+      ).to.throw(
+        `Consider reducing the targets as the sum (240.5) is greater than sum of collaterals (230.5)`,
+      );
+    });
+
     it('should handle case where there is not enough surplus to meet all minimum requirements by scaling down deficits', () => {
       const config = {
         [chain1]: {

package/src/strategy/MinAmountStrategy.ts

@@ -1,8 +1,12 @@
 import { BigNumber } from 'bignumber.js';
 import { type Logger } from 'pino';
 
-import { type ChainMap, type Token } from '@humanode-hyperlane/sdk';
-import { fromWei, toWei } from '@humanode-hyperlane/utils';
+import {
+  localAmountFromMessage,
+  type ChainMap,
+  type Token,
+} from '@humanode-hyperlane/sdk';
+import { fromWei } from '@humanode-hyperlane/utils';
 
 import {
   type MinAmountStrategyConfig,
@@ -16,6 +20,7 @@ import type {
 } from '../interfaces/IStrategy.js';
 import { type Metrics } from '../metrics/Metrics.js';
 import type { BridgeConfigWithOverride } from '../utils/bridgeUtils.js';
+import { normalizeConfiguredAmount } from '../utils/balanceUtils.js';
 
 import { BaseStrategy, type Delta } from './BaseStrategy.js';
 
@@ -116,9 +121,13 @@ export class MinAmountStrategy extends BaseStrategy {
         if (chainConfig.minAmount.type === RebalancerMinAmountType.Absolute) {
           const token = this.getTokenByChainName(chain);
 
-          minAmount = BigInt(toWei(chainConfig.minAmount.min, token.decimals));
-          targetAmount = BigInt(
-            toWei(chainConfig.minAmount.target, token.decimals),
+          minAmount = normalizeConfiguredAmount(
+            chainConfig.minAmount.min,
+            token,
+          );
+          targetAmount = normalizeConfiguredAmount(
+            chainConfig.minAmount.target,
+            token,
           );
         } else {
           minAmount = BigInt(
@@ -172,29 +181,32 @@ export class MinAmountStrategy extends BaseStrategy {
 
     if (minAmountType === RebalancerMinAmountType.Absolute) {
       let totalTargets = 0n;
-      let decimals: number = 0;
+      const displayToken = this.getTokenByChainName(this.chains[0]);
 
       for (const chainName of this.chains) {
         const token = this.getTokenByChainName(chainName);
-        // all the tokens have the same amount of decimals
-        decimals = token.decimals;
-
-        totalTargets += BigInt(
-          toWei(config[chainName].minAmount.target, token.decimals),
+        totalTargets += normalizeConfiguredAmount(
+          config[chainName].minAmount.target,
+          token,
         );
       }
 
       if (totalTargets > totalCollateral) {
         throw new Error(
-          `Consider reducing the targets as the sum (${fromWei(
-            totalTargets.toString(),
-            decimals,
-          )}) is greater than sum of collaterals (${fromWei(
-            totalCollateral.toString(),
-            decimals,
+          `Consider reducing the targets as the sum (${this.formatCanonicalAmount(
+            totalTargets,
+            displayToken,
+          )}) is greater than sum of collaterals (${this.formatCanonicalAmount(
+            totalCollateral,
+            displayToken,
           )})`,
         );
       }
     }
   }
+
+  private formatCanonicalAmount(amount: bigint, token: Token): string {
+    const localAmount = localAmountFromMessage(amount, token.scale);
+    return fromWei(localAmount.toString(), token.decimals);
+  }
 }

package/src/test/helpers.ts

@@ -6,10 +6,11 @@ import {
   type ChainMetadata,
   type ChainName,
   EvmMovableCollateralAdapter,
+  type IToken,
   type InterchainGasQuote,
   type MultiProvider,
   type Token,
-  type TokenAmount,
+  TokenAmount,
   type WarpCore,
 } from '@humanode-hyperlane/sdk';
 
@@ -115,17 +116,14 @@ export function buildTestPreparedTransaction(
 
 // === Mock Factories ===
 
-export function createMockTokenAmount(amount: bigint): TokenAmount {
-  return {
-    amount,
-    token: {
-      name: 'TestToken',
-      symbol: 'TEST',
-      decimals: 18,
-      addressOrDenom: TEST_ADDRESSES.token,
-    },
-    getDecimalFormattedAmount: () => ethers.utils.formatEther(amount),
-  } as unknown as TokenAmount;
+export function createMockTokenAmount(amount: bigint): TokenAmount<IToken> {
+  const token = {
+    name: 'TestToken',
+    symbol: 'TEST',
+    decimals: 18,
+    addressOrDenom: TEST_ADDRESSES.token,
+  } as IToken;
+  return new TokenAmount(amount, token);
 }
 
 export interface MockAdapterConfig {
@@ -173,6 +171,7 @@ export interface MockTokenConfig {
   name?: string;
   decimals?: number;
   addressOrDenom?: string;
+  scale?: Token['scale'];
   adapter?: ReturnType<typeof createMockAdapter>;
 }
 
@@ -181,6 +180,7 @@ export function createMockToken(config: MockTokenConfig = {}) {
     name = 'TestToken',
     decimals = 18,
     addressOrDenom = TEST_ADDRESSES.token,
+    scale,
     adapter = createMockAdapter(),
   } = config;
 
@@ -188,6 +188,7 @@ export function createMockToken(config: MockTokenConfig = {}) {
     name,
     decimals,
     addressOrDenom,
+    scale,
     amount: (amt: bigint) => createMockTokenAmount(amt),
     getHypAdapter: Sinon.stub().returns(adapter),
   };

package/src/test/lifiMocks.ts

@@ -128,15 +128,18 @@ export function createMockBridgeQuote(
   const route = overrides?.route as
     | { action?: { fromChainId?: number; toChainId?: number } }
     | undefined;
+  const usesReverseQuote = overrides?.requestParams?.toAmount !== undefined;
 
   const defaultRequestParams: BridgeQuoteParams = {
     fromChain: 42161,
     toChain: 1399811149,
     fromToken: '0xCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC',
     toToken: '0xCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC',
-    fromAddress: '0xAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA',
     toAddress: '0xAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA',
-    fromAmount: 10000000000n,
+    fromAddress: '0xAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA',
+    ...(usesReverseQuote
+      ? { toAmount: 9950000000n }
+      : { fromAmount: 10000000000n }),
   };
   const requestParams: BridgeQuoteParams = {
     ...defaultRequestParams,

package/src/test/pendingTransferMiddlewareMocks.ts

@@ -0,0 +1,65 @@
+import type { Logger } from 'pino';
+
+import type {
+  ExplorerMessage,
+  IExplorerClient,
+  RebalanceActionQueryParams,
+  UserTransferQueryParams,
+} from '../utils/ExplorerClient.js';
+
+export const ID_A =
+  '0x8960c5e41eb0d91973140ebc196892f5f07f512dd86047e8536e71424462c5d3';
+export const ID_B =
+  '0xdae65a8dd678bf8ea03faed7d53b99e52f5bdbae7c95834eff009cc37a18103c';
+export const ID_C =
+  '0x1c3b5f0e2d4a6c8e0f1a2b3c4d5e6f708192a3b4c5d6e7f8091a2b3c4d5e6f70';
+
+export const PARAMS: UserTransferQueryParams = {
+  routersByDomain: { 1: '0x67899664446ccfadf75e0d3f5668be262acd1069' },
+  excludeTxSenders: ['0x995a921d333029512aa166885856c8af760e9381'],
+};
+
+export const REBALANCE_PARAMS: RebalanceActionQueryParams = {
+  bridges: ['0x867a19a5b257bcb99e1840de2ef852268efd5e46'],
+  routersByDomain: PARAMS.routersByDomain,
+  rebalancerAddress: '0x995a921d333029512aa166885856c8af760e9381',
+};
+
+export function buildMessage(msgId: string): ExplorerMessage {
+  return {
+    msg_id: msgId,
+    origin_domain_id: 42161,
+    destination_domain_id: 1,
+    sender: '0x867a19a5b257bcb99e1840de2ef852268efd5e46',
+    recipient: '0x67899664446ccfadf75e0d3f5668be262acd1069',
+    origin_tx_hash:
+      '0x5e3c1f6a3c1a7f86e0f2d5e9c9c1b8d1e1e7e2b6c4d8a9f0e1d2c3b4a5968778',
+    origin_tx_sender: '0x995a921d333029512aa166885856c8af760e9381',
+    origin_tx_recipient: '0x867a19a5b257bcb99e1840de2ef852268efd5e46',
+    is_delivered: false,
+    message_body: `0x${'00'.repeat(63)}64`,
+    send_occurred_at: null,
+  };
+}
+
+export class StubExplorerClient implements IExplorerClient {
+  readonly userTransferParams: UserTransferQueryParams[] = [];
+  rebalanceActions: ExplorerMessage[] = [buildMessage(ID_C)];
+
+  constructor(public userTransfers: ExplorerMessage[]) {}
+
+  async getInflightUserTransfers(
+    params: UserTransferQueryParams,
+    _logger: Logger,
+  ): Promise<ExplorerMessage[]> {
+    this.userTransferParams.push(params);
+    return this.userTransfers;
+  }
+
+  async getInflightRebalanceActions(
+    _params: RebalanceActionQueryParams,
+    _logger: Logger,
+  ): Promise<ExplorerMessage[]> {
+    return this.rebalanceActions;
+  }
+}