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

package/src/factories/RebalancerContextFactory.ts

@@ -14,12 +14,11 @@ import {
 import {
   Address,
   assert,
+  isEVMLike,
   ProtocolType,
   objMap,
-  toWei,
 } from '@humanode-hyperlane/utils';
 
-import { LiFiBridge } from '../bridges/LiFiBridge.js';
 import { type RebalancerConfig } from '../config/RebalancerConfig.js';
 import {
   ExecutionType,
@@ -50,6 +49,7 @@ import {
 } from '../tracking/ActionTracker.js';
 import type { IActionTracker } from '../tracking/IActionTracker.js';
 import { InflightContextAdapter } from '../tracking/InflightContextAdapter.js';
+import { buildPendingTransferMiddlewares } from '../tracking/pendingTransferMiddlewares/buildPendingTransferMiddlewares.js';
 import { InMemoryStore } from '../tracking/store/index.js';
 import type {
   RebalanceAction,
@@ -63,6 +63,10 @@ import {
   ExplorerClient,
   type IExplorerClient,
 } from '../utils/ExplorerClient.js';
+import {
+  normalizeConfiguredAmount,
+  normalizeToCanonical,
+} from '../utils/balanceUtils.js';
 import { isCollateralizedTokenEligibleForRebalancing } from '../utils/tokenUtils.js';
 
 const DEFAULT_EXPLORER_URL =
@@ -139,7 +143,7 @@ export class RebalancerContextFactory {
       ...new Set(warpCoreConfig.tokens.map((t) => t.chainName)),
     ];
     for (const chain of warpChains) {
-      if (multiProvider.getProtocol(chain) !== ProtocolType.Ethereum) {
+      if (!isEVMLike(multiProvider.getProtocol(chain))) {
         logger.debug({ chain }, 'Skipping provider init for non-EVM chain');
         continue;
       }
@@ -252,9 +256,13 @@ export class RebalancerContextFactory {
       );
       if (chainConfig?.bridgeMinAcceptedAmount) {
         const token = this.tokensByChainName[chainName];
-        const decimals = token?.decimals ?? 18;
-        minAmountsByChain[chainName] = BigInt(
-          toWei(chainConfig.bridgeMinAcceptedAmount, decimals),
+        assert(
+          token,
+          `No token found for configured strategy chain ${chainName} in warp route ${this.config.warpRouteId}`,
+        );
+        minAmountsByChain[chainName] = normalizeConfiguredAmount(
+          chainConfig.bridgeMinAcceptedAmount,
+          token,
         );
       }
     }
@@ -321,7 +329,7 @@ export class RebalancerContextFactory {
       RebalanceActionStatus
     >();
 
-    const explorerClient =
+    const baseExplorerClient =
       typeof explorerUrlOrClient === 'string'
         ? new ExplorerClient(explorerUrlOrClient, (domain) =>
             this.multiProvider.getProtocol(domain),
@@ -366,16 +374,40 @@ export class RebalancerContextFactory {
       routersByDomain[domain] = token.addressOrDenom;
     }
 
+    const mailboxByDomain: Record<number, string> = {};
+    for (const [chain, addresses] of Object.entries(coreAddresses)) {
+      mailboxByDomain[this.multiProvider.getDomainId(chain)] =
+        addresses.mailbox;
+    }
+
+    const {
+      client: explorerClient,
+      isIgnoredTransfer,
+      isIgnoredRebalanceAction,
+    } = await buildPendingTransferMiddlewares(
+      baseExplorerClient,
+      this.config.pendingTransferMiddlewares ?? [],
+      {
+        routersByDomain,
+        mailboxByDomain,
+        multiProvider: this.multiProvider,
+        logger: this.logger,
+      },
+    );
+
     const trackerConfig: ActionTrackerConfig = {
       routersByDomain,
+      isIgnoredTransfer,
+      isIgnoredRebalanceAction,
       bridges,
       rebalancerAddress,
       inventorySignerAddresses: this.config.inventorySigners
-        ? (Object.entries(this.config.inventorySigners)
-            .filter(([protocol]) => protocol === ProtocolType.Ethereum)
-            .map(([, signerConfig]) => signerConfig)
-            .map((s) => s.address)
-            .filter(Boolean) as Address[])
+        ? Object.values(ProtocolType)
+            .filter((protocol) => isEVMLike(protocol))
+            .map(
+              (protocol) => this.config.inventorySigners?.[protocol]?.address,
+            )
+            .filter((address): address is Address => Boolean(address))
         : undefined,
       intentTTL: this.config.intentTTL,
     };
@@ -459,6 +491,13 @@ export class RebalancerContextFactory {
       return null;
     }
 
+    for (const chain of allRelevantChains) {
+      assert(
+        this.tokensByChainName[chain],
+        `No token found for inventory-relevant chain ${chain} in warp route ${this.config.warpRouteId}`,
+      );
+    }
+
     const requiredProtocols = new Set(
       allRelevantChains.map((chain) => {
         const metadata = this.warpCore.multiProvider.getChainMetadata(chain);
@@ -472,6 +511,7 @@ export class RebalancerContextFactory {
     const SUPPORTED_INVENTORY_PROTOCOLS = new Set([
       ProtocolType.Ethereum,
       ProtocolType.Sealevel,
+      ProtocolType.Tron,
     ]);
     for (const protocol of requiredProtocols) {
       const chainsForProtocol = allRelevantChains.filter(
@@ -481,7 +521,7 @@ export class RebalancerContextFactory {
       );
       assert(
         SUPPORTED_INVENTORY_PROTOCOLS.has(protocol),
-        `Inventory rebalancing does not support protocol '${protocol}' (chains: ${chainsForProtocol.join(', ')}). Supported: ethereum, sealevel`,
+        `Inventory rebalancing does not support protocol '${protocol}' (chains: ${chainsForProtocol.join(', ')}). Supported: ethereum, sealevel, tron`,
       );
     }
     for (const protocol of requiredProtocols) {
@@ -511,7 +551,8 @@ export class RebalancerContextFactory {
     }
 
     const externalBridgeRegistry: Partial<ExternalBridgeRegistry> =
-      externalBridgeRegistryOverride ?? this.buildExternalBridgeRegistry();
+      externalBridgeRegistryOverride ??
+      (await this.buildExternalBridgeRegistry());
 
     if (Object.keys(externalBridgeRegistry).length === 0) {
       if (externalBridgeRegistryOverride !== undefined) {
@@ -523,12 +564,12 @@ export class RebalancerContextFactory {
           'No external bridges configured, skipping inventory components',
         );
       }
-      const inventoryAddresses = Object.fromEntries(
-        Object.entries(inventorySigners).map(([protocol, cfg]) => [
-          protocol,
-          cfg.address,
-        ]),
-      ) as Partial<Record<ProtocolType, Address>>;
+      const inventoryAddresses: Partial<Record<ProtocolType, Address>> = {};
+      for (const protocol of Object.values(ProtocolType)) {
+        const cfg = inventorySigners[protocol];
+        if (!cfg) continue;
+        inventoryAddresses[protocol] = cfg.address;
+      }
       const inventoryConfig: InventoryMonitorConfig = {
         inventoryAddresses,
         chains: allRelevantChains,
@@ -537,11 +578,12 @@ export class RebalancerContextFactory {
       const mergedSigners: Partial<
         Record<ProtocolType, InventorySignerConfig>
       > = {};
-      for (const [protocol, cfg] of Object.entries(inventorySigners)) {
-        const protocolKey = protocol as ProtocolType;
-        mergedSigners[protocolKey] = {
+      for (const protocol of Object.values(ProtocolType)) {
+        const cfg = inventorySigners[protocol];
+        if (!cfg) continue;
+        mergedSigners[protocol] = {
           address: cfg.address,
-          key: cfg.key ?? this.inventorySignerKeysByProtocol?.[protocolKey],
+          key: cfg.key ?? this.inventorySignerKeysByProtocol?.[protocol],
         };
       }
       const inventoryRebalancer = new InventoryRebalancer(
@@ -563,12 +605,12 @@ export class RebalancerContextFactory {
     }
 
     // 3. Build inventory config
-    const inventoryAddresses = Object.fromEntries(
-      Object.entries(inventorySigners).map(([protocol, cfg]) => [
-        protocol,
-        cfg.address,
-      ]),
-    ) as Partial<Record<ProtocolType, Address>>;
+    const inventoryAddresses: Partial<Record<ProtocolType, Address>> = {};
+    for (const protocol of Object.values(ProtocolType)) {
+      const cfg = inventorySigners[protocol];
+      if (!cfg) continue;
+      inventoryAddresses[protocol] = cfg.address;
+    }
     const inventoryConfig: InventoryMonitorConfig = {
       inventoryAddresses,
       chains: allRelevantChains,
@@ -578,11 +620,12 @@ export class RebalancerContextFactory {
     // Merge config addresses with runtime keys
     const mergedSigners: Partial<Record<ProtocolType, InventorySignerConfig>> =
       {};
-    for (const [protocol, cfg] of Object.entries(inventorySigners)) {
-      const protocolKey = protocol as ProtocolType;
-      mergedSigners[protocolKey] = {
+    for (const protocol of Object.values(ProtocolType)) {
+      const cfg = inventorySigners[protocol];
+      if (!cfg) continue;
+      mergedSigners[protocol] = {
         address: cfg.address,
-        key: cfg.key ?? this.inventorySignerKeysByProtocol?.[protocolKey],
+        key: cfg.key ?? this.inventorySignerKeysByProtocol?.[protocol],
       };
     }
     const inventoryRebalancer = new InventoryRebalancer(
@@ -608,7 +651,9 @@ export class RebalancerContextFactory {
     return { inventoryRebalancer, externalBridgeRegistry, inventoryConfig };
   }
 
-  private buildExternalBridgeRegistry(): Partial<ExternalBridgeRegistry> {
+  private async buildExternalBridgeRegistry(): Promise<
+    Partial<ExternalBridgeRegistry>
+  > {
     const { externalBridges } = this.config;
     const registry: Partial<ExternalBridgeRegistry> = {};
 
@@ -617,6 +662,7 @@ export class RebalancerContextFactory {
         case ExternalBridgeType.LiFi: {
           const lifiConfig = externalBridges?.lifi;
           if (lifiConfig?.integrator) {
+            const { LiFiBridge } = await import('../bridges/LiFiBridge.js');
             registry[ExternalBridgeType.LiFi] = new LiFiBridge(
               {
                 integrator: lifiConfig.integrator,
@@ -761,7 +807,11 @@ export class RebalancerContextFactory {
         ) {
           const adapter = token.getHypAdapter(this.warpCore.multiProvider);
           const bridgedSupply = await adapter.getBridgedSupply();
-          initialTotalCollateral += bridgedSupply ?? 0n;
+          assert(
+            bridgedSupply !== undefined,
+            `Missing bridged supply for ${token.chainName} while computing initial total collateral for warp route ${this.config.warpRouteId}`,
+          );
+          initialTotalCollateral += normalizeToCanonical(bridgedSupply, token);
         }
       }),
     );

package/src/index.ts

@@ -24,6 +24,7 @@ export {
   DEFAULT_INTENT_TTL_S,
   getStrategyChainConfig,
   getStrategyChainNames,
+  PendingTransferMiddlewareType,
   RebalancerBaseChainConfigSchema,
   RebalancerConfigSchema,
   RebalancerMinAmountConfigSchema,
@@ -35,6 +36,7 @@ export {
 } from './config/types.js';
 export type {
   MinAmountStrategyConfig,
+  PendingTransferMiddlewareConfig,
   RebalancerConfig as RebalancerConfigType,
   RebalancerConfigFileInput,
   RebalancerMinAmountChainConfig,

package/src/interfaces/IRebalancer.ts

@@ -1,5 +1,6 @@
 import {
   type EvmMovableCollateralAdapter,
+  type IToken,
   type TokenAmount,
 } from '@humanode-hyperlane/sdk';
 
@@ -48,10 +49,12 @@ export type IInventoryRebalancer = IRebalancer<
   InventoryExecutionResult
 >;
 
+type PreparedOriginTokenAmount = TokenAmount<IToken>;
+
 export type PreparedTransaction = {
   populatedTx: Awaited<
     ReturnType<EvmMovableCollateralAdapter['populateRebalanceTx']>
   >;
   route: MovableCollateralRoute & { intentId: string };
-  originTokenAmount: TokenAmount;
+  originTokenAmount: PreparedOriginTokenAmount;
 };

package/src/metrics/Metrics.ts

@@ -274,6 +274,7 @@ export class Metrics implements IMetrics {
                     this.warpCore.multiProvider,
                     token,
                     lockbox.lockbox,
+                    balance.tokenAddress,
                   );
 
                 updateManagedLockboxBalanceMetrics(

package/src/metrics/PriceGetter.test.ts

@@ -0,0 +1,113 @@
+import { expect } from 'chai';
+import { pino } from 'pino';
+import Sinon from 'sinon';
+
+import { CoinGeckoTokenPriceGetter } from '@humanode-hyperlane/sdk';
+
+import { PriceGetter } from './PriceGetter.js';
+
+const logger = pino({ level: 'silent' });
+const response = (price = 1) =>
+  new Response(
+    JSON.stringify({
+      'usd-coin': { usd: price },
+      tether: { usd: price },
+    }),
+  );
+
+describe('PriceGetter concurrent lookups', () => {
+  afterEach(() => Sinon.restore());
+
+  it('reduces twelve concurrent same-ID HTTP requests to one', async () => {
+    const fetch = Sinon.stub(globalThis, 'fetch').callsFake(async () =>
+      response(),
+    );
+    const baseline = new CoinGeckoTokenPriceGetter({
+      chainMetadata: {},
+      sleepMsBetweenRequests: 0,
+    });
+    const before = await Promise.all(
+      Array.from({ length: 12 }, () =>
+        baseline.getTokenPriceByIds(['usd-coin']),
+      ),
+    );
+    expect(fetch.callCount).to.equal(12);
+    fetch.resetHistory();
+
+    const getter = PriceGetter.create({}, logger, undefined, undefined, 0);
+    const after = await Promise.all(
+      Array.from({ length: 12 }, () => getter.getCoingeckoPrice('usd-coin')),
+    );
+    expect(fetch.callCount).to.equal(1);
+    expect(after).to.deep.equal(before.map((prices) => prices?.[0]));
+  });
+
+  it('looks up distinct IDs independently', async () => {
+    const fetch = Sinon.stub(globalThis, 'fetch').callsFake(async () =>
+      response(),
+    );
+    const getter = PriceGetter.create({}, logger, undefined, undefined, 0);
+    expect(
+      await Promise.all([
+        getter.getCoingeckoPrice('usd-coin'),
+        getter.getCoingeckoPrice('tether'),
+        getter.getCoingeckoPrice('usd-coin'),
+        getter.getCoingeckoPrice('tether'),
+      ]),
+    ).to.deep.equal([1, 1, 1, 1]);
+    expect(fetch.callCount).to.equal(2);
+  });
+
+  it('keeps the SDK cache behavior after a successful lookup', async () => {
+    const fetch = Sinon.stub(globalThis, 'fetch').callsFake(async () =>
+      response(),
+    );
+    const getter = PriceGetter.create({}, logger, undefined, 60, 0);
+    expect(await getter.getCoingeckoPrice('usd-coin')).to.equal(1);
+    expect(await getter.getCoingeckoPrice('usd-coin')).to.equal(1);
+    expect(fetch.callCount).to.equal(1);
+  });
+
+  it('does not retain settled results beyond the SDK cache lifetime', async () => {
+    const fetch = Sinon.stub(globalThis, 'fetch');
+    fetch.onFirstCall().resolves(response(1));
+    fetch.onSecondCall().resolves(response(2));
+    const getter = PriceGetter.create({}, logger, undefined, 0, 0);
+    expect(await getter.getCoingeckoPrice('usd-coin')).to.equal(1);
+    expect(await getter.getCoingeckoPrice('usd-coin')).to.equal(2);
+    expect(fetch.callCount).to.equal(2);
+  });
+
+  it('retries after an unavailable price instead of retaining undefined', async () => {
+    const fetch = Sinon.stub(globalThis, 'fetch');
+    fetch.onFirstCall().resolves(new Response('{}'));
+    fetch.onSecondCall().resolves(response());
+    const getter = PriceGetter.create({}, logger, undefined, undefined, 0);
+    expect(
+      await Promise.all([
+        getter.getCoingeckoPrice('usd-coin'),
+        getter.getCoingeckoPrice('usd-coin'),
+      ]),
+    ).to.deep.equal([undefined, undefined]);
+    expect(await getter.getCoingeckoPrice('usd-coin')).to.equal(1);
+    expect(fetch.callCount).to.equal(2);
+  });
+
+  it('propagates rejected lookups to all callers and allows a retry', async () => {
+    const getter = PriceGetter.create({}, logger);
+    const lookup = Sinon.stub(getter, 'getTokenPriceByIds');
+    const error = new Error('price lookup rejected');
+    lookup.onFirstCall().rejects(error);
+    lookup.onSecondCall().resolves([2]);
+    const results = await Promise.allSettled([
+      getter.getCoingeckoPrice('usd-coin'),
+      getter.getCoingeckoPrice('usd-coin'),
+    ]);
+    expect(results).to.deep.equal([
+      { status: 'rejected', reason: error },
+      { status: 'rejected', reason: error },
+    ]);
+    expect(await getter.getCoingeckoPrice('usd-coin')).to.equal(2);
+    expect(lookup.callCount).to.equal(2);
+  });
+});

package/src/metrics/PriceGetter.ts

@@ -9,6 +9,10 @@ import {
 
 export class PriceGetter extends CoinGeckoTokenPriceGetter {
   private readonly logger: Logger;
+  private readonly pendingPrices = new Map<
+    string,
+    Promise<number | undefined>
+  >();
 
   private constructor({
     chainMetadata,
@@ -67,8 +71,19 @@ export class PriceGetter extends CoinGeckoTokenPriceGetter {
   }
 
   async getCoingeckoPrice(coingeckoId: string): Promise<number | undefined> {
-    const prices = await this.getTokenPriceByIds([coingeckoId]);
-    if (!prices) return undefined;
-    return prices[0];
+    const pending = this.pendingPrices.get(coingeckoId);
+    if (pending) return pending;
+
+    // Multiple route tokens can share an ID. Share only the active lookup;
+    // the SDK remains responsible for cache freshness and failed-price handling.
+    const request = this.getTokenPriceByIds([coingeckoId]).then(
+      (prices) => prices?.[0],
+    );
+    this.pendingPrices.set(coingeckoId, request);
+    try {
+      return await request;
+    } finally {
+      this.pendingPrices.delete(coingeckoId);
+    }
   }
 }