@humanode-hyperlane/rebalancer 0.0.0-stage → 27.2.2-humanode.1

package/src/e2e/weighted.e2e-test.ts

@@ -0,0 +1,304 @@
+import { expect } from 'chai';
+import { BigNumber, providers } from 'ethers';
+
+import {
+  HyperlaneCore,
+  MultiProvider,
+  snapshot,
+} from '@humanode-hyperlane/sdk';
+
+import {
+  RebalancerStrategyOptions,
+  type StrategyConfig,
+} from '../config/types.js';
+
+import {
+  DOMAIN_IDS,
+  type DeployedAddresses,
+  TEST_CHAINS,
+} from './fixtures/routes.js';
+import { getAllCollateralBalances } from './harness/BridgeSetup.js';
+import { type LocalDeploymentContext } from './harness/BaseLocalDeploymentManager.js';
+import { Erc20LocalDeploymentManager } from './harness/Erc20LocalDeploymentManager.js';
+import { resetSnapshotsAndRefreshProviders } from './harness/SnapshotHelper.js';
+import { getFirstMonitorEvent } from './harness/TestHelpers.js';
+import { TestRebalancer } from './harness/TestRebalancer.js';
+import { tryRelayMessage } from './harness/TransferHelper.js';
+
+describe('WeightedStrategy E2E', function () {
+  this.timeout(300_000);
+
+  let deploymentManager: Erc20LocalDeploymentManager;
+  let multiProvider: MultiProvider;
+  let localProviders: Map<string, providers.JsonRpcProvider>;
+  let snapshotIds: Map<string, string>;
+  let hyperlaneCore: HyperlaneCore;
+  let deployedAddresses: DeployedAddresses;
+  let weightedStrategyConfig: StrategyConfig[];
+
+  before(async function () {
+    deploymentManager = new Erc20LocalDeploymentManager();
+    const ctx: LocalDeploymentContext<DeployedAddresses> =
+      await deploymentManager.start();
+    multiProvider = ctx.multiProvider;
+    localProviders = ctx.providers;
+    deployedAddresses = ctx.deployedAddresses;
+
+    const coreAddresses: Record<string, Record<string, string>> = {};
+    for (const chain of TEST_CHAINS) {
+      coreAddresses[chain] = {
+        mailbox: deployedAddresses.chains[chain].mailbox,
+        interchainSecurityModule: deployedAddresses.chains[chain].ism,
+      };
+    }
+    hyperlaneCore = HyperlaneCore.fromAddressesMap(
+      coreAddresses,
+      multiProvider,
+    );
+
+    weightedStrategyConfig = [
+      {
+        rebalanceStrategy: RebalancerStrategyOptions.Weighted,
+        chains: {
+          anvil1: {
+            weighted: { weight: 60n, tolerance: 5n },
+            bridge: deployedAddresses.bridgeRoute1.anvil1,
+          },
+          anvil2: {
+            weighted: { weight: 20n, tolerance: 5n },
+            bridge: deployedAddresses.bridgeRoute1.anvil2,
+          },
+          anvil3: {
+            weighted: { weight: 20n, tolerance: 5n },
+            bridge: deployedAddresses.bridgeRoute1.anvil3,
+          },
+        },
+      },
+    ];
+
+    snapshotIds = new Map();
+    for (const [chain, provider] of localProviders) {
+      snapshotIds.set(chain, await snapshot(provider));
+    }
+  });
+
+  afterEach(async function () {
+    await resetSnapshotsAndRefreshProviders({
+      localProviders,
+      multiProvider,
+      snapshotIds,
+    });
+  });
+
+  after(async function () {
+    if (deploymentManager) {
+      await deploymentManager.stop();
+    }
+  });
+
+  it('should propose rebalance routes when weights are unbalanced', async function () {
+    const context = await TestRebalancer.builder(
+      deploymentManager,
+      multiProvider,
+    )
+      .withStrategy(weightedStrategyConfig)
+      .withBalances('WEIGHTED_IMBALANCED')
+      .withExecutionMode('execute')
+      .build();
+
+    const monitor = context.createMonitor(0);
+    const event = await getFirstMonitorEvent(monitor);
+
+    await context.orchestrator.executeCycle(event);
+
+    // Assert: Strategy created rebalance intent for the imbalanced chain
+    const activeIntents = await context.tracker.getActiveRebalanceIntents();
+    expect(activeIntents.length).to.equal(1);
+    expect(activeIntents[0].origin).to.equal(DOMAIN_IDS.anvil1);
+    expect(activeIntents[0].destination).to.equal(DOMAIN_IDS.anvil3);
+    expect(activeIntents[0].amount).to.equal(1000000000n);
+  });
+
+  it('should not propose routes when within tolerance', async function () {
+    const context = await TestRebalancer.builder(
+      deploymentManager,
+      multiProvider,
+    )
+      .withStrategy(weightedStrategyConfig)
+      .withBalances('WEIGHTED_WITHIN_TOLERANCE')
+      .withExecutionMode('execute')
+      .build();
+
+    const monitor = context.createMonitor(0);
+    const event = await getFirstMonitorEvent(monitor);
+
+    await context.orchestrator.executeCycle(event);
+
+    // Assert: No intents created when within tolerance
+    const activeIntents = await context.tracker.getActiveRebalanceIntents();
+    expect(activeIntents.length).to.equal(0);
+  });
+
+  it('should execute full rebalance cycle with actual transfers', async function () {
+    const context = await TestRebalancer.builder(
+      deploymentManager,
+      multiProvider,
+    )
+      .withStrategy(weightedStrategyConfig)
+      .withBalances('WEIGHTED_IMBALANCED')
+      .withExecutionMode('execute')
+      .build();
+
+    const monitor = context.createMonitor(0);
+    const event = await getFirstMonitorEvent(monitor);
+    await context.orchestrator.executeCycle(event);
+
+    // Assert: Rebalance intent was created with correct fields
+    const activeIntents = await context.tracker.getActiveRebalanceIntents();
+    expect(activeIntents.length).to.equal(1);
+    expect(activeIntents[0].destination).to.equal(DOMAIN_IDS.anvil3);
+    expect(activeIntents[0].amount).to.equal(1000000000n);
+    expect(activeIntents[0].status).to.equal('in_progress');
+
+    // Assert: Rebalance action was created
+    const inProgressActions = await context.tracker.getInProgressActions();
+    expect(inProgressActions.length).to.equal(1);
+    expect(inProgressActions[0].intentId).to.equal(activeIntents[0].id);
+
+    // Assert: Ethereum balance decreased by 1000 USDC (rebalance amount)
+    const balancesAfterRebalance = await getAllCollateralBalances(
+      localProviders,
+      TEST_CHAINS,
+      deployedAddresses.monitoredRoute,
+      deployedAddresses.tokens,
+    );
+
+    // Initial: 7000 USDC - Rebalance: 1000 USDC = 6000 USDC
+    expect(
+      balancesAfterRebalance.anvil1.toString(),
+      'anvil1 collateral should be 6000 USDC after rebalance',
+    ).to.equal('6000000000');
+
+    // Capture action details for relay
+    const actionToBase = inProgressActions[0];
+    const ethProvider = localProviders.get('anvil1')!;
+
+    // Relay the rebalance message to destination
+    expect(actionToBase.txHash, 'Action should have txHash').to.exist;
+    const rebalanceTxReceipt = await ethProvider.getTransactionReceipt(
+      actionToBase.txHash!,
+    );
+    const rebalanceRelayResult = await tryRelayMessage(
+      multiProvider,
+      hyperlaneCore,
+      {
+        dispatchTx: rebalanceTxReceipt,
+        messageId: actionToBase.messageId!,
+        origin: 'anvil1',
+        destination: 'anvil3',
+      },
+    );
+    expect(
+      rebalanceRelayResult.success,
+      `Rebalance relay should succeed: ${rebalanceRelayResult.error}`,
+    ).to.be.true;
+
+    const blockTags = await context.getConfirmedBlockTags();
+    await context.tracker.syncRebalanceActions(blockTags);
+
+    // Assert: Action is now complete
+    const completedAction = await context.tracker.getRebalanceAction(
+      actionToBase.id,
+    );
+    expect(completedAction!.status).to.equal('complete');
+
+    // Assert: Intent is now complete
+    const completedIntent = await context.tracker.getRebalanceIntent(
+      activeIntents[0].id,
+    );
+    expect(completedIntent!.status).to.equal('complete');
+
+    // Assert: No more in-progress actions
+    const remainingActions = await context.tracker.getInProgressActions();
+    expect(remainingActions.length).to.equal(0);
+  });
+
+  it('should handle stuck transfer and propose routes to destination', async function () {
+    // Build context with Weighted strategy
+    // Initial: eth=7000, arb=2000, base=1000 (total=10000)
+    // Target: eth=60% (6000), arb=20% (2000), base=20% (2000)
+    // Cycle 1 will create inflight eth→base for ~1000 USDC
+    const context = await TestRebalancer.builder(
+      deploymentManager,
+      multiProvider,
+    )
+      .withStrategy(weightedStrategyConfig)
+      .withBalances('WEIGHTED_IMBALANCED')
+      .withExecutionMode('execute')
+      .build();
+
+    // ===== CYCLE 1: Execute rebalance to create inflight eth→base =====
+    const monitor1 = context.createMonitor(0);
+    const event1 = await getFirstMonitorEvent(monitor1);
+    await context.orchestrator.executeCycle(event1);
+
+    const blockTags1 = await context.getConfirmedBlockTags();
+    await context.tracker.syncRebalanceActions(blockTags1);
+
+    const inflightAfterCycle1 = await context.tracker.getInProgressActions();
+    expect(
+      inflightAfterCycle1.length,
+      'Cycle 1 should create inflight action',
+    ).to.be.greaterThan(0);
+
+    const inflightToBase = inflightAfterCycle1.find(
+      (a) =>
+        a.destination === DOMAIN_IDS.anvil3 && a.origin === DOMAIN_IDS.anvil1,
+    );
+    expect(inflightToBase, 'Should have inflight action eth→base').to.exist;
+
+    const inflightAmount = BigNumber.from(inflightToBase!.amount);
+    expect(inflightAmount.gt(0), 'Inflight amount should be positive').to.be
+      .true;
+
+    // ===== CYCLE 2: Execute again - should account for inflight =====
+    // Weighted now sees: base effective = current + inflight ≈ 2000 (target)
+    // Should create reduced amount or nothing to base
+    const monitor2 = context.createMonitor(0);
+    const event2 = await getFirstMonitorEvent(monitor2);
+    await context.orchestrator.executeCycle(event2);
+
+    const blockTags2 = await context.getConfirmedBlockTags();
+    await context.tracker.syncRebalanceActions(blockTags2);
+
+    // Check if new actions to base were created
+    const inProgressAfterCycle2 = await context.tracker.getInProgressActions();
+    const newActionsToBase = inProgressAfterCycle2.filter(
+      (a) =>
+        a.destination === DOMAIN_IDS.anvil3 &&
+        a.id !== inflightToBase!.id &&
+        a.status === 'in_progress',
+    );
+
+    if (newActionsToBase.length > 0) {
+      // If action was created, should be much smaller than original 1000 USDC
+      const proposedAmount = BigNumber.from(
+        newActionsToBase[0].amount,
+      ).toBigInt();
+      expect(
+        proposedAmount < 500000000n,
+        `Amount to base (${proposedAmount}) should be reduced accounting for inflight`,
+      ).to.be.true;
+    }
+    // If no new action to base, that's valid (within tolerance after inflight)
+
+    // Verify inflight still exists and action tracking is working
+    const finalInProgress = await context.tracker.getInProgressActions();
+    const inflightStillActive = finalInProgress.find(
+      (a) => a.id === inflightToBase!.id,
+    );
+    expect(inflightStillActive, 'Inflight action should still be tracked').to
+      .exist;
+    expect(inflightStillActive!.status).to.equal('in_progress');
+  });
+});

package/src/factories/RebalancerContextFactory.test.ts

@@ -0,0 +1,394 @@
+import { expect } from 'chai';
+import { pino } from 'pino';
+import Sinon from 'sinon';
+
+import { type IRegistry, RegistryType } from '@humanode-hyperlane/registry';
+import {
+  MultiProtocolProvider,
+  MultiProvider,
+  TokenStandard,
+  type WarpCoreConfig,
+} from '@humanode-hyperlane/sdk';
+import { ProtocolType, assert } from '@humanode-hyperlane/utils';
+
+import type { RebalancerConfig } from '../config/RebalancerConfig.js';
+import {
+  ExecutionType,
+  DEFAULT_INTENT_TTL_MS,
+  RebalancerStrategyOptions,
+} from '../config/types.js';
+import { TEST_ADDRESSES } from '../test/helpers.js';
+
+import { RebalancerContextFactory } from './RebalancerContextFactory.js';
+
+const testLogger = pino({ level: 'silent' });
+
+function createMockRegistry(): IRegistry {
+  return {
+    type: RegistryType.Partial,
+    uri: 'mock://registry',
+    getUri: Sinon.stub().returns('mock://registry'),
+    listRegistryContent: Sinon.stub().resolves({
+      chains: {},
+      deployments: { warpRoutes: {}, warpDeployConfig: {} },
+    }),
+    getChains: Sinon.stub().resolves([]),
+    getMetadata: Sinon.stub().resolves({}),
+    getChainMetadata: Sinon.stub().resolves(null),
+    getAddresses: Sinon.stub().resolves({
+      ethereum: { mailbox: TEST_ADDRESSES.ethereum },
+      arbitrum: { mailbox: TEST_ADDRESSES.arbitrum },
+      paradex: { mailbox: TEST_ADDRESSES.polygon },
+    }),
+    getChainAddresses: Sinon.stub().resolves({
+      mailbox: TEST_ADDRESSES.ethereum,
+    }),
+    getChainLogoUri: Sinon.stub().resolves(null),
+    addChain: Sinon.stub().resolves(),
+    updateChain: Sinon.stub().resolves(),
+    removeChain: Sinon.stub().resolves(),
+    getWarpRoute: Sinon.stub().resolves(null),
+    getWarpRoutes: Sinon.stub().resolves({}),
+    addWarpRoute: Sinon.stub().resolves(),
+    addWarpRouteConfig: Sinon.stub().resolves(),
+    getWarpDeployConfig: Sinon.stub().resolves({}),
+    getWarpDeployConfigs: Sinon.stub().resolves({}),
+    merge: Sinon.stub().returnsThis(),
+  };
+}
+
+function createMockConfig(): RebalancerConfig {
+  return {
+    warpRouteId: 'USDC/paradex',
+    strategyConfig: [
+      {
+        rebalanceStrategy: RebalancerStrategyOptions.Weighted,
+        chains: {
+          ethereum: {
+            bridge: TEST_ADDRESSES.bridge,
+            bridgeMinAcceptedAmount: 0,
+            weighted: { weight: 50n, tolerance: 10n },
+          },
+          arbitrum: {
+            bridge: TEST_ADDRESSES.bridge,
+            bridgeMinAcceptedAmount: 0,
+            weighted: { weight: 50n, tolerance: 10n },
+          },
+        },
+      },
+    ],
+    intentTTL: DEFAULT_INTENT_TTL_MS,
+  } as RebalancerConfig;
+}
+
+function createMockMpp() {
+  const mpp = Sinon.createStubInstance(MultiProtocolProvider);
+  mpp.extendChainMetadata.returnsThis();
+  return mpp;
+}
+
+function createToken(
+  chainName: string,
+  addressOrDenom: string,
+  standard: TokenStandard,
+) {
+  return {
+    chainName,
+    addressOrDenom,
+    standard,
+    decimals: 6,
+    symbol: 'USDC',
+    name: 'USDC',
+  };
+}
+
+interface ChainDef {
+  name: string;
+  protocol: ProtocolType;
+}
+
+function createMockMultiProvider(chains: ChainDef[]) {
+  const protocolMap = Object.fromEntries(
+    chains.map((c) => [c.name, c.protocol]),
+  );
+
+  const multiProvider = Sinon.createStubInstance(MultiProvider);
+  multiProvider.getProtocol.callsFake((chain) => {
+    const protocol = protocolMap[String(chain)];
+    assert(protocol, `No protocol in mock for chain ${chain}`);
+    return protocol;
+  });
+
+  return { multiProvider };
+}
+
+async function createFactory(
+  config: RebalancerConfig,
+  multiProvider: MultiProvider,
+  warpCoreConfig: WarpCoreConfig,
+) {
+  return RebalancerContextFactory.create(
+    config,
+    multiProvider,
+    createMockMpp(),
+    createMockRegistry(),
+    testLogger,
+    undefined,
+    warpCoreConfig,
+  );
+}
+
+async function callCreate(
+  multiProvider: MultiProvider,
+  warpCoreConfig: WarpCoreConfig,
+) {
+  await createFactory(createMockConfig(), multiProvider, warpCoreConfig);
+}
+
+describe('RebalancerContextFactory', () => {
+  let sandbox: Sinon.SinonSandbox;
+
+  beforeEach(() => {
+    sandbox = Sinon.createSandbox();
+  });
+
+  afterEach(() => {
+    sandbox.restore();
+  });
+
+  describe('create() — non-EVM chain handling', () => {
+    it('should skip provider initialization for StarkNet chains', async () => {
+      const { multiProvider } = createMockMultiProvider([
+        { name: 'ethereum', protocol: ProtocolType.Ethereum },
+        { name: 'arbitrum', protocol: ProtocolType.Ethereum },
+        { name: 'paradex', protocol: ProtocolType.Starknet },
+      ]);
+
+      await callCreate(multiProvider, {
+        tokens: [
+          createToken(
+            'ethereum',
+            TEST_ADDRESSES.ethereum,
+            TokenStandard.EvmHypCollateral,
+          ),
+          createToken(
+            'arbitrum',
+            TEST_ADDRESSES.arbitrum,
+            TokenStandard.EvmHypSynthetic,
+          ),
+          createToken(
+            'paradex',
+            '0xparadex',
+            TokenStandard.StarknetHypSynthetic,
+          ),
+        ],
+      });
+
+      expect(multiProvider.getProvider.callCount).to.equal(2);
+      const providerChains = multiProvider.getProvider
+        .getCalls()
+        .map((c) => c.args[0]);
+      expect(providerChains).to.include('ethereum');
+      expect(providerChains).to.include('arbitrum');
+      expect(providerChains).to.not.include('paradex');
+    });
+
+    it('should skip provider initialization for Sealevel chains', async () => {
+      const { multiProvider } = createMockMultiProvider([
+        { name: 'ethereum', protocol: ProtocolType.Ethereum },
+        { name: 'solana', protocol: ProtocolType.Sealevel },
+      ]);
+
+      await callCreate(multiProvider, {
+        tokens: [
+          createToken(
+            'ethereum',
+            TEST_ADDRESSES.ethereum,
+            TokenStandard.EvmHypCollateral,
+          ),
+          createToken(
+            'solana',
+            'SolToken111',
+            TokenStandard.SealevelHypSynthetic,
+          ),
+        ],
+      });
+
+      expect(multiProvider.getProvider.callCount).to.equal(1);
+      expect(multiProvider.getProvider.firstCall.args[0]).to.equal('ethereum');
+    });
+
+    it('should call getProvider for all chains when all are EVM', async () => {
+      const { multiProvider } = createMockMultiProvider([
+        { name: 'ethereum', protocol: ProtocolType.Ethereum },
+        { name: 'arbitrum', protocol: ProtocolType.Ethereum },
+      ]);
+
+      await callCreate(multiProvider, {
+        tokens: [
+          createToken(
+            'ethereum',
+            TEST_ADDRESSES.ethereum,
+            TokenStandard.EvmHypCollateral,
+          ),
+          createToken(
+            'arbitrum',
+            TEST_ADDRESSES.arbitrum,
+            TokenStandard.EvmHypSynthetic,
+          ),
+        ],
+      });
+
+      expect(multiProvider.getProvider.callCount).to.equal(2);
+      const providerChains = multiProvider.getProvider
+        .getCalls()
+        .map((c) => c.args[0]);
+      expect(providerChains).to.include('ethereum');
+      expect(providerChains).to.include('arbitrum');
+    });
+
+    it('should fail early when inventory override origin protocol signer key is missing', async () => {
+      const sealevelChain = 'solana';
+      const evmChain = 'ethereum';
+      const { multiProvider } = createMockMultiProvider([
+        { name: evmChain, protocol: ProtocolType.Ethereum },
+        { name: sealevelChain, protocol: ProtocolType.Sealevel },
+      ]);
+
+      const config = {
+        warpRouteId: 'USDC/mixed-route',
+        strategyConfig: [
+          {
+            rebalanceStrategy: RebalancerStrategyOptions.Weighted,
+            chains: {
+              [sealevelChain]: {
+                bridge: TEST_ADDRESSES.bridge,
+                weighted: { weight: 50n, tolerance: 10n },
+                override: {
+                  [evmChain]: {
+                    executionType: ExecutionType.Inventory,
+                  },
+                },
+              },
+              [evmChain]: {
+                bridge: TEST_ADDRESSES.bridge,
+                weighted: { weight: 50n, tolerance: 10n },
+              },
+            },
+          },
+        ],
+        inventorySigners: {
+          [ProtocolType.Ethereum]: {
+            address: TEST_ADDRESSES.ethereum,
+            key: '0xabc123',
+          },
+        },
+        intentTTL: DEFAULT_INTENT_TTL_MS,
+      } as RebalancerConfig;
+
+      const factory = await createFactory(config, multiProvider, {
+        tokens: [
+          createToken(
+            evmChain,
+            TEST_ADDRESSES.ethereum,
+            TokenStandard.EvmHypSynthetic,
+          ),
+          createToken(
+            sealevelChain,
+            'SolToken1111111111111111111111111111111111111',
+            TokenStandard.SealevelHypCollateral,
+          ),
+        ],
+      });
+
+      const getChainMetadataStub = factory.getWarpCore().multiProvider
+        .getChainMetadata as Sinon.SinonStub;
+      getChainMetadataStub.callsFake((chainName: string) => ({
+        protocol:
+          chainName === sealevelChain
+            ? ProtocolType.Sealevel
+            : ProtocolType.Ethereum,
+      }));
+
+      await expect(
+        (factory as any).createInventoryRebalancerAndConfig({} as any, {}),
+      ).to.be.rejectedWith(
+        `Missing inventory signer key for protocol ${ProtocolType.Sealevel}`,
+      );
+    });
+
+    it('should fail early when inventory chain uses unsupported protocol', async () => {
+      const cosmosChain = 'cosmoshub';
+      const evmChain = 'ethereum';
+      const { multiProvider } = createMockMultiProvider([
+        { name: evmChain, protocol: ProtocolType.Ethereum },
+        { name: cosmosChain, protocol: ProtocolType.Cosmos },
+      ]);
+
+      const config = {
+        warpRouteId: 'USDC/cosmos-route',
+        strategyConfig: [
+          {
+            rebalanceStrategy: RebalancerStrategyOptions.Weighted,
+            chains: {
+              [cosmosChain]: {
+                bridge: TEST_ADDRESSES.bridge,
+                weighted: { weight: 50n, tolerance: 10n },
+                override: {
+                  [evmChain]: {
+                    executionType: ExecutionType.Inventory,
+                  },
+                },
+              },
+              [evmChain]: {
+                bridge: TEST_ADDRESSES.bridge,
+                weighted: { weight: 50n, tolerance: 10n },
+              },
+            },
+          },
+        ],
+        inventorySigners: {
+          [ProtocolType.Ethereum]: {
+            address: TEST_ADDRESSES.ethereum,
+            key: '0xabc123',
+          },
+          [ProtocolType.Cosmos]: {
+            address: 'cosmos1qypqxpq9qcrsszg2pvxq6rs0zqg3yyc5lzv7xu',
+            key: 'cosmos_key',
+          },
+        },
+        intentTTL: DEFAULT_INTENT_TTL_MS,
+      } as RebalancerConfig;
+
+      const factory = await createFactory(config, multiProvider, {
+        tokens: [
+          createToken(
+            evmChain,
+            TEST_ADDRESSES.ethereum,
+            TokenStandard.EvmHypSynthetic,
+          ),
+          createToken(
+            cosmosChain,
+            'cosmos1token',
+            TokenStandard.EvmHypSynthetic,
+          ),
+        ],
+      });
+
+      const getChainMetadataStub = factory.getWarpCore().multiProvider
+        .getChainMetadata as Sinon.SinonStub;
+      getChainMetadataStub.callsFake((chainName: string) => ({
+        protocol:
+          chainName === cosmosChain
+            ? ProtocolType.Cosmos
+            : ProtocolType.Ethereum,
+      }));
+
+      await expect(
+        (factory as any).createInventoryRebalancerAndConfig({} as any, {}),
+      ).to.be.rejectedWith(
+        `Inventory rebalancing does not support protocol '${ProtocolType.Cosmos}'`,
+      );
+    });
+  });
+});