@humanode-hyperlane/rebalancer 0.0.0-stage → 27.2.2

package/src/strategy/MinAmountStrategy.test.ts

@@ -0,0 +1,732 @@
+import { AddressZero } from '@ethersproject/constants';
+import { expect } from 'chai';
+import { pino } from 'pino';
+
+import {
+  type ChainMap,
+  type ChainName,
+  Token,
+  TokenStandard,
+} from '@humanode-hyperlane/sdk';
+
+import { RebalancerMinAmountType } from '../config/types.js';
+import type { RawBalances } from '../interfaces/IStrategy.js';
+import { extractBridgeConfigs } from '../test/helpers.js';
+
+import { MinAmountStrategy } from './MinAmountStrategy.js';
+
+const testLogger = pino({ level: 'silent' });
+
+describe('MinAmountStrategy', () => {
+  let chain1: ChainName;
+  let chain2: ChainName;
+  let chain3: ChainName;
+  const tokensByChainName: ChainMap<Token> = {};
+  const tokenArgs = {
+    name: 'token',
+    decimals: 18,
+    symbol: 'TOKEN',
+    standard: TokenStandard.ERC20,
+    addressOrDenom: '',
+  };
+  const totalCollateral = BigInt(300e18);
+
+  beforeEach(() => {
+    chain1 = 'chain1';
+    chain2 = 'chain2';
+    chain3 = 'chain3';
+    tokensByChainName[chain1] = new Token({ ...tokenArgs, chainName: chain1 });
+    tokensByChainName[chain2] = new Token({ ...tokenArgs, chainName: chain2 });
+    tokensByChainName[chain3] = new Token({ ...tokenArgs, chainName: chain3 });
+  });
+
+  describe('constructor', () => {
+    it('should throw an error when less than two chains are configured', () => {
+      expect(
+        () =>
+          new MinAmountStrategy(
+            {
+              [chain1]: {
+                minAmount: {
+                  min: '100',
+                  target: '120',
+                  type: RebalancerMinAmountType.Absolute,
+                },
+                bridge: AddressZero,
+                bridgeLockTime: 1,
+              },
+            },
+            tokensByChainName,
+            totalCollateral,
+            testLogger,
+            {},
+          ),
+      ).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(
+        {
+          [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,
+          },
+        },
+        tokensByChainName,
+        totalCollateral,
+        testLogger,
+        {},
+      );
+    });
+
+    // 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(
+        {
+          [chain1]: {
+            minAmount: {
+              min: 0.3,
+              target: 0.4,
+              type: RebalancerMinAmountType.Relative,
+            },
+            bridge: AddressZero,
+            bridgeLockTime: 1,
+          },
+          [chain2]: {
+            minAmount: {
+              min: 0.4,
+              target: 0.5,
+              type: RebalancerMinAmountType.Relative,
+            },
+            bridge: AddressZero,
+            bridgeLockTime: 1,
+          },
+        },
+        tokensByChainName,
+        totalCollateral,
+        testLogger,
+        {},
+      );
+    });
+
+    it('should throw an error when minAmount is negative', () => {
+      expect(
+        () =>
+          new MinAmountStrategy(
+            {
+              [chain1]: {
+                minAmount: {
+                  min: 100,
+                  target: '120',
+                  type: RebalancerMinAmountType.Absolute,
+                },
+                bridge: AddressZero,
+                bridgeLockTime: 1,
+              },
+              [chain2]: {
+                minAmount: {
+                  min: '-10',
+                  target: '120',
+                  type: RebalancerMinAmountType.Absolute,
+                },
+                bridge: AddressZero,
+                bridgeLockTime: 1,
+              },
+            },
+            tokensByChainName,
+            totalCollateral,
+            testLogger,
+            {},
+          ),
+      ).to.throw('Minimum amount (-10) cannot be negative for chain chain2');
+    });
+
+    it('should throw an error when target is less than min', () => {
+      expect(
+        () =>
+          new MinAmountStrategy(
+            {
+              [chain1]: {
+                minAmount: {
+                  min: '100',
+                  target: '80',
+                  type: RebalancerMinAmountType.Absolute,
+                },
+                bridge: AddressZero,
+                bridgeLockTime: 1,
+              },
+              [chain2]: {
+                minAmount: {
+                  min: '100',
+                  target: '120',
+                  type: RebalancerMinAmountType.Absolute,
+                },
+                bridge: AddressZero,
+                bridgeLockTime: 1,
+              },
+            },
+            tokensByChainName,
+            totalCollateral,
+            testLogger,
+            {},
+          ),
+      ).to.throw(
+        'Target (80) must be greater than or equal to min (100) for chain chain1',
+      );
+    });
+
+    it('should throw an error when relative target is less than relative min', () => {
+      expect(
+        () =>
+          new MinAmountStrategy(
+            {
+              [chain1]: {
+                minAmount: {
+                  min: 0.5,
+                  target: 0.4,
+                  type: RebalancerMinAmountType.Relative,
+                },
+                bridge: AddressZero,
+                bridgeLockTime: 1,
+              },
+              [chain2]: {
+                minAmount: {
+                  min: 0.3,
+                  target: 0.5,
+                  type: RebalancerMinAmountType.Relative,
+                },
+                bridge: AddressZero,
+                bridgeLockTime: 1,
+              },
+            },
+            tokensByChainName,
+            totalCollateral,
+            testLogger,
+            {},
+          ),
+      ).to.throw(
+        'Target (0.4) must be greater than or equal to min (0.5) for chain chain1',
+      );
+    });
+
+    it('should throw an error when raw balances chains length does not match configured chains length', () => {
+      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,
+            },
+          },
+          tokensByChainName,
+          totalCollateral,
+          testLogger,
+          {},
+        ).getRebalancingRoutes({
+          [chain1]: 100n,
+          [chain2]: 200n,
+          [chain3]: 300n,
+        }),
+      ).to.throw('Config chains do not match raw balances chains length');
+    });
+
+    it('should throw an error when a raw balance is missing', () => {
+      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,
+            },
+          },
+          tokensByChainName,
+          totalCollateral,
+          testLogger,
+          {},
+        ).getRebalancingRoutes({
+          [chain1]: 100n,
+          [chain3]: 300n,
+        } as RawBalances),
+      ).to.throw('Raw balance for chain chain2 not found');
+    });
+
+    it('should throw an error when a raw balance is negative', () => {
+      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,
+            },
+          },
+          tokensByChainName,
+          totalCollateral,
+          testLogger,
+          {},
+        ).getRebalancingRoutes({
+          [chain1]: 100n,
+          [chain2]: -2n,
+        }),
+      ).to.throw('Raw balance for chain chain2 is negative');
+    });
+  });
+
+  describe('getRebalancingRoutes', () => {
+    it('should return an empty array when all chains have at least the minimum amount', () => {
+      const strategy = 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,
+          },
+        },
+        tokensByChainName,
+        totalCollateral,
+        testLogger,
+        {},
+      );
+
+      const rawBalances: RawBalances = {
+        [chain1]: BigInt(120e18),
+        [chain2]: BigInt(120e18),
+      };
+
+      const routes = strategy.getRebalancingRoutes(rawBalances);
+
+      expect(routes).to.be.empty;
+    });
+
+    it('should return a single route when a chain is below minimum amount', () => {
+      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 bridgeConfigs = extractBridgeConfigs(config);
+      const strategy = new MinAmountStrategy(
+        config,
+        tokensByChainName,
+        totalCollateral,
+        testLogger,
+        bridgeConfigs,
+      );
+
+      const rawBalances = {
+        [chain1]: BigInt(50e18),
+        [chain2]: BigInt(200e18),
+      };
+
+      const routes = strategy.getRebalancingRoutes(rawBalances);
+
+      expect(routes).to.deep.equal([
+        {
+          origin: chain2,
+          destination: chain1,
+          amount: BigInt(70e18),
+          bridge: AddressZero,
+          executionType: 'movableCollateral',
+        },
+      ]);
+    });
+
+    it('should return multiple routes for multiple chains below minimum amount', () => {
+      const config = {
+        [chain1]: {
+          minAmount: {
+            min: '80',
+            target: '100',
+            type: RebalancerMinAmountType.Absolute,
+          },
+          bridge: AddressZero,
+          bridgeLockTime: 1,
+        },
+        [chain2]: {
+          minAmount: {
+            min: '80',
+            target: '100',
+            type: RebalancerMinAmountType.Absolute,
+          },
+          bridge: AddressZero,
+          bridgeLockTime: 1,
+        },
+        [chain3]: {
+          minAmount: {
+            min: '80',
+            target: '100',
+            type: RebalancerMinAmountType.Absolute,
+          },
+          bridge: AddressZero,
+          bridgeLockTime: 1,
+        },
+      };
+      const bridgeConfigs = extractBridgeConfigs(config);
+      const strategy = new MinAmountStrategy(
+        config,
+        tokensByChainName,
+        totalCollateral,
+        testLogger,
+        bridgeConfigs,
+      );
+
+      const rawBalances = {
+        [chain1]: BigInt(50e18),
+        [chain2]: BigInt(75e18),
+        [chain3]: BigInt(300e18),
+      };
+
+      const routes = strategy.getRebalancingRoutes(rawBalances);
+
+      expect(routes).to.deep.equal([
+        {
+          origin: chain3,
+          destination: chain1,
+          amount: BigInt(50e18),
+          bridge: AddressZero,
+          executionType: 'movableCollateral',
+        },
+        {
+          origin: chain3,
+          destination: chain2,
+          amount: BigInt(25e18),
+          bridge: AddressZero,
+          executionType: 'movableCollateral',
+        },
+      ]);
+    });
+
+    it('should throw an error when the sum of `target` is greater than the sum of collaterals', () => {
+      expect(
+        () =>
+          new MinAmountStrategy(
+            {
+              [chain1]: {
+                minAmount: {
+                  min: '100',
+                  target: '220',
+                  type: RebalancerMinAmountType.Absolute,
+                },
+                bridge: AddressZero,
+                bridgeLockTime: 1,
+              },
+              [chain2]: {
+                minAmount: {
+                  min: '100',
+                  target: '120',
+                  type: RebalancerMinAmountType.Absolute,
+                },
+                bridge: AddressZero,
+                bridgeLockTime: 1,
+              },
+            },
+            tokensByChainName,
+            totalCollateral,
+            testLogger,
+            {},
+          ),
+      ).to.throw(
+        `Consider reducing the targets as the sum (340) is greater than sum of collaterals (300)`,
+      );
+    });
+
+    it('should handle case where there is not enough surplus to meet all minimum requirements by scaling down deficits', () => {
+      const config = {
+        [chain1]: {
+          minAmount: {
+            min: '100',
+            target: '100',
+            type: RebalancerMinAmountType.Absolute,
+          },
+          bridge: AddressZero,
+          bridgeLockTime: 1,
+        },
+        [chain2]: {
+          minAmount: {
+            min: '100',
+            target: '100',
+            type: RebalancerMinAmountType.Absolute,
+          },
+          bridge: AddressZero,
+          bridgeLockTime: 1,
+        },
+        [chain3]: {
+          minAmount: {
+            min: '100',
+            target: '100',
+            type: RebalancerMinAmountType.Absolute,
+          },
+          bridge: AddressZero,
+          bridgeLockTime: 1,
+        },
+      };
+      const bridgeConfigs = extractBridgeConfigs(config);
+      const strategy = new MinAmountStrategy(
+        config,
+        tokensByChainName,
+        totalCollateral,
+        testLogger,
+        bridgeConfigs,
+      );
+
+      const rawBalances = {
+        [chain1]: BigInt(50e18),
+        [chain2]: BigInt(50e18),
+        [chain3]: BigInt(150e18), // Only 50n of surplus, not enough to bring both chains up to minimum
+      };
+
+      const routes = strategy.getRebalancingRoutes(rawBalances);
+
+      // It scales down the deficits to prevent sending all surplus to a single chain
+      expect(routes.length).to.equal(2);
+      expect(routes[0].origin).to.equal(chain3);
+      expect(routes[0].destination).to.equal(chain1);
+      expect(routes[0].amount).to.equal(BigInt(25e18));
+      expect(routes[1].origin).to.equal(chain3);
+      expect(routes[1].destination).to.equal(chain2);
+      expect(routes[1].amount).to.equal(BigInt(25e18));
+    });
+
+    it('should not produce zero-amount routes when scaling causes amounts to round to zero', () => {
+      // This test ensures that when deficit scaling produces zero amounts (due to integer division),
+      // these zero-amount routes are NOT included in the output.
+      // Bug scenario: totalSurplus=1, totalDeficit=3 -> each deficit of 1 scales to (1*1)/3 = 0
+      const config = {
+        [chain1]: {
+          minAmount: {
+            min: '90',
+            target: '100',
+            type: RebalancerMinAmountType.Absolute,
+          },
+          bridge: AddressZero,
+          bridgeLockTime: 1,
+        },
+        [chain2]: {
+          minAmount: {
+            min: '90',
+            target: '100',
+            type: RebalancerMinAmountType.Absolute,
+          },
+          bridge: AddressZero,
+          bridgeLockTime: 1,
+        },
+        [chain3]: {
+          minAmount: {
+            min: '90',
+            target: '100',
+            type: RebalancerMinAmountType.Absolute,
+          },
+          bridge: AddressZero,
+          bridgeLockTime: 1,
+        },
+      };
+      const bridgeConfigs = extractBridgeConfigs(config);
+      const strategy = new MinAmountStrategy(
+        config,
+        tokensByChainName,
+        totalCollateral,
+        testLogger,
+        bridgeConfigs,
+      );
+
+      // chain1 and chain2 are at 1 token each (far below min 90)
+      // chain3 has 91 tokens (surplus of 1 above min)
+      // Deficits: chain1 needs 99 (100-1), chain2 needs 99 (100-1), total = 198
+      // Surplus: chain3 has 1 (91-90)
+      // Scaling: each deficit of 99 becomes (99 * 1) / 198 = 0 (integer division!)
+      const rawBalances = {
+        [chain1]: BigInt(1e18),
+        [chain2]: BigInt(1e18),
+        [chain3]: BigInt(91e18),
+      };
+
+      const routes = strategy.getRebalancingRoutes(rawBalances);
+
+      // All routes should have non-zero amounts
+      // (Chai's greaterThan doesn't support BigInt, so use direct comparison)
+      for (const route of routes) {
+        expect(
+          route.amount > 0n,
+          `Route amount should be > 0, got ${route.amount}`,
+        ).to.be.true;
+      }
+
+      // The single token of surplus may produce one route (or none if both scale to 0)
+      // Either way, no zero-amount routes should exist
+      expect(
+        routes.every((r) => r.amount > 0n),
+        'All routes must have non-zero amounts',
+      ).to.be.true;
+    });
+
+    it('should have no surplus or deficit when all at min', () => {
+      const strategy = new MinAmountStrategy(
+        {
+          [chain1]: {
+            minAmount: {
+              min: '100',
+              target: '100',
+              type: RebalancerMinAmountType.Absolute,
+            },
+            bridge: AddressZero,
+            bridgeLockTime: 1,
+          },
+          [chain2]: {
+            minAmount: {
+              min: '100',
+              target: '100',
+              type: RebalancerMinAmountType.Absolute,
+            },
+            bridge: AddressZero,
+            bridgeLockTime: 1,
+          },
+        },
+        tokensByChainName,
+        totalCollateral,
+        testLogger,
+        {},
+      );
+
+      const rawBalances = {
+        [chain1]: BigInt(100e18),
+        [chain2]: BigInt(100e18),
+      };
+
+      const routes = strategy.getRebalancingRoutes(rawBalances);
+
+      expect(routes).to.be.empty;
+    });
+
+    it('should consider the target amount with relative configuration', () => {
+      const config = {
+        [chain1]: {
+          minAmount: {
+            min: 0.25,
+            target: 0.3,
+            type: RebalancerMinAmountType.Relative,
+          },
+          bridge: AddressZero,
+          bridgeLockTime: 1,
+        },
+        [chain2]: {
+          minAmount: {
+            min: 0.25,
+            target: 0.3,
+            type: RebalancerMinAmountType.Relative,
+          },
+          bridge: AddressZero,
+          bridgeLockTime: 1,
+        },
+      };
+      const bridgeConfigs = extractBridgeConfigs(config);
+      const strategy = new MinAmountStrategy(
+        config,
+        tokensByChainName,
+        totalCollateral,
+        testLogger,
+        bridgeConfigs,
+      );
+
+      const rawBalances: RawBalances = {
+        [chain1]: 200n,
+        [chain2]: 800n,
+      };
+
+      const routes = strategy.getRebalancingRoutes(rawBalances);
+
+      expect(routes).to.deep.equal([
+        {
+          origin: chain2,
+          destination: chain1,
+          amount: 100n,
+          bridge: AddressZero,
+          executionType: 'movableCollateral',
+        },
+      ]);
+    });
+  });
+});