@hyperlane-xyz/rebalancer 0.1.2 → 1.0.0

package/src/config/RebalancerConfig.test.ts

@@ -3,6 +3,7 @@ import { ethers } from 'ethers';
 import { rmSync } from 'fs';
 import { tmpdir } from 'os';
 import { join } from 'path';
+import type { z } from 'zod';
 
 import { writeYamlOrJson } from '@hyperlane-xyz/utils/fs';
 
@@ -11,37 +12,49 @@ import {
   type RebalancerConfigFileInput,
   RebalancerMinAmountType,
   RebalancerStrategyOptions,
+  type StrategyConfig,
+  getAllBridges,
 } from './types.js';
 
 const TEST_CONFIG_PATH = join(tmpdir(), 'rebalancer-config-test.yaml');
 
+// Helper to get strategy as array (for test type safety)
+// Schema accepts both single object and array, but tests use array format
+function getStrategyArray(
+  data: RebalancerConfigFileInput,
+): z.input<typeof import('./types.js').StrategyConfigSchema>[] {
+  return Array.isArray(data.strategy) ? data.strategy : [data.strategy];
+}
+
 describe('RebalancerConfig', () => {
   let data: RebalancerConfigFileInput;
 
   beforeEach(() => {
     data = {
       warpRouteId: 'warpRouteId',
-      strategy: {
-        rebalanceStrategy: RebalancerStrategyOptions.Weighted,
-        chains: {
-          chain1: {
-            weighted: {
-              weight: 100,
-              tolerance: 0,
+      strategy: [
+        {
+          rebalanceStrategy: RebalancerStrategyOptions.Weighted,
+          chains: {
+            chain1: {
+              weighted: {
+                weight: 100,
+                tolerance: 0,
+              },
+              bridge: ethers.constants.AddressZero,
+              bridgeLockTime: 1,
             },
-            bridge: ethers.constants.AddressZero,
-            bridgeLockTime: 1,
-          },
-          chain2: {
-            weighted: {
-              weight: 100,
-              tolerance: 0,
+            chain2: {
+              weighted: {
+                weight: 100,
+                tolerance: 0,
+              },
+              bridge: ethers.constants.AddressZero,
+              bridgeLockTime: 1,
             },
-            bridge: ethers.constants.AddressZero,
-            bridgeLockTime: 1,
           },
         },
-      },
+      ],
     };
 
     writeYamlOrJson(TEST_CONFIG_PATH, data);
@@ -62,32 +75,34 @@ describe('RebalancerConfig', () => {
   it('should load config from file', () => {
     expect(RebalancerConfig.load(TEST_CONFIG_PATH)).to.deep.equal({
       warpRouteId: 'warpRouteId',
-      strategyConfig: {
-        rebalanceStrategy: RebalancerStrategyOptions.Weighted,
-        chains: {
-          chain1: {
-            weighted: {
-              weight: 100n,
-              tolerance: 0n,
+      strategyConfig: [
+        {
+          rebalanceStrategy: RebalancerStrategyOptions.Weighted,
+          chains: {
+            chain1: {
+              weighted: {
+                weight: 100n,
+                tolerance: 0n,
+              },
+              bridge: ethers.constants.AddressZero,
+              bridgeLockTime: 1_000,
             },
-            bridge: ethers.constants.AddressZero,
-            bridgeLockTime: 1_000,
-          },
-          chain2: {
-            weighted: {
-              weight: 100n,
-              tolerance: 0n,
+            chain2: {
+              weighted: {
+                weight: 100n,
+                tolerance: 0n,
+              },
+              bridge: ethers.constants.AddressZero,
+              bridgeLockTime: 1_000,
             },
-            bridge: ethers.constants.AddressZero,
-            bridgeLockTime: 1_000,
           },
         },
-      },
+      ],
     });
   });
 
   it('should throw if chains are not configured', () => {
-    data.strategy.chains = {};
+    getStrategyArray(data)[0].chains = {};
 
     writeYamlOrJson(TEST_CONFIG_PATH, data);
 
@@ -110,37 +125,39 @@ describe('RebalancerConfig', () => {
   it('should load relative params without modifications', () => {
     data = {
       warpRouteId: 'warpRouteId',
-      strategy: {
-        rebalanceStrategy: RebalancerStrategyOptions.MinAmount,
-        chains: {
-          chain1: {
-            minAmount: {
-              min: '0.2',
-              target: 0.3,
-              type: RebalancerMinAmountType.Relative,
+      strategy: [
+        {
+          rebalanceStrategy: RebalancerStrategyOptions.MinAmount,
+          chains: {
+            chain1: {
+              minAmount: {
+                min: '0.2',
+                target: 0.3,
+                type: RebalancerMinAmountType.Relative,
+              },
+              bridge: ethers.constants.AddressZero,
+              bridgeLockTime: 1,
             },
-            bridge: ethers.constants.AddressZero,
-            bridgeLockTime: 1,
-          },
-          chain2: {
-            minAmount: {
-              min: '0.2',
-              target: 0.3,
-              type: RebalancerMinAmountType.Relative,
+            chain2: {
+              minAmount: {
+                min: '0.2',
+                target: 0.3,
+                type: RebalancerMinAmountType.Relative,
+              },
+              bridge: ethers.constants.AddressZero,
+              bridgeLockTime: 1,
             },
-            bridge: ethers.constants.AddressZero,
-            bridgeLockTime: 1,
           },
         },
-      },
+      ],
     };
 
     writeYamlOrJson(TEST_CONFIG_PATH, data);
 
     expect(
-      RebalancerConfig.load(TEST_CONFIG_PATH).strategyConfig.chains.chain1,
+      RebalancerConfig.load(TEST_CONFIG_PATH).strategyConfig[0].chains.chain1,
     ).to.deep.equal({
-      ...data.strategy.chains.chain1,
+      ...getStrategyArray(data)[0].chains.chain1,
       bridgeLockTime: 1_000,
     });
   });
@@ -148,37 +165,39 @@ describe('RebalancerConfig', () => {
   it('should load absolute params without modifications', () => {
     data = {
       warpRouteId: 'warpRouteId',
-      strategy: {
-        rebalanceStrategy: RebalancerStrategyOptions.MinAmount,
-        chains: {
-          chain1: {
-            minAmount: {
-              min: '100000',
-              target: 140000,
-              type: RebalancerMinAmountType.Absolute,
+      strategy: [
+        {
+          rebalanceStrategy: RebalancerStrategyOptions.MinAmount,
+          chains: {
+            chain1: {
+              minAmount: {
+                min: '100000',
+                target: 140000,
+                type: RebalancerMinAmountType.Absolute,
+              },
+              bridge: ethers.constants.AddressZero,
+              bridgeLockTime: 1,
             },
-            bridge: ethers.constants.AddressZero,
-            bridgeLockTime: 1,
-          },
-          chain2: {
-            minAmount: {
-              min: '100000',
-              target: 140000,
-              type: RebalancerMinAmountType.Absolute,
+            chain2: {
+              minAmount: {
+                min: '100000',
+                target: 140000,
+                type: RebalancerMinAmountType.Absolute,
+              },
+              bridge: ethers.constants.AddressZero,
+              bridgeLockTime: 1,
             },
-            bridge: ethers.constants.AddressZero,
-            bridgeLockTime: 1,
           },
         },
-      },
+      ],
     };
 
     writeYamlOrJson(TEST_CONFIG_PATH, data);
 
     expect(
-      RebalancerConfig.load(TEST_CONFIG_PATH).strategyConfig.chains.chain1,
+      RebalancerConfig.load(TEST_CONFIG_PATH).strategyConfig[0].chains.chain1,
     ).to.deep.equal({
-      ...data.strategy.chains.chain1,
+      ...getStrategyArray(data)[0].chains.chain1,
       bridgeLockTime: 1_000,
     });
   });
@@ -187,51 +206,54 @@ describe('RebalancerConfig', () => {
     it('should parse a config with overrides', () => {
       data = {
         warpRouteId: 'warpRouteId',
-        strategy: {
-          rebalanceStrategy: RebalancerStrategyOptions.MinAmount,
-          chains: {
-            chain1: {
-              minAmount: {
-                min: 1000,
-                target: 1100,
-                type: RebalancerMinAmountType.Absolute,
-              },
-              bridge: ethers.constants.AddressZero,
-              bridgeLockTime: 1,
-              override: {
-                chain2: {
-                  bridge: '0x1234567890123456789012345678901234567890',
+        strategy: [
+          {
+            rebalanceStrategy: RebalancerStrategyOptions.MinAmount,
+            chains: {
+              chain1: {
+                minAmount: {
+                  min: 1000,
+                  target: 1100,
+                  type: RebalancerMinAmountType.Absolute,
+                },
+                bridge: ethers.constants.AddressZero,
+                bridgeLockTime: 1,
+                override: {
+                  chain2: {
+                    bridge: '0x1234567890123456789012345678901234567890',
+                  },
                 },
               },
-            },
-            chain2: {
-              minAmount: {
-                min: 2000,
-                target: 2200,
-                type: RebalancerMinAmountType.Absolute,
+              chain2: {
+                minAmount: {
+                  min: 2000,
+                  target: 2200,
+                  type: RebalancerMinAmountType.Absolute,
+                },
+                bridge: ethers.constants.AddressZero,
+                bridgeLockTime: 1,
               },
-              bridge: ethers.constants.AddressZero,
-              bridgeLockTime: 1,
-            },
-            chain3: {
-              minAmount: {
-                min: 3000,
-                target: 3300,
-                type: RebalancerMinAmountType.Absolute,
+              chain3: {
+                minAmount: {
+                  min: 3000,
+                  target: 3300,
+                  type: RebalancerMinAmountType.Absolute,
+                },
+                bridge: ethers.constants.AddressZero,
+                bridgeLockTime: 1,
               },
-              bridge: ethers.constants.AddressZero,
-              bridgeLockTime: 1,
             },
           },
-        },
+        ],
       };
 
       writeYamlOrJson(TEST_CONFIG_PATH, data);
 
       const config = RebalancerConfig.load(TEST_CONFIG_PATH);
-      expect(config.strategyConfig.chains.chain1).to.have.property('override');
+      const chainConfig = config.strategyConfig[0].chains.chain1;
+      expect(chainConfig).to.have.property('override');
 
-      const override = config.strategyConfig.chains.chain1.override;
+      const override = chainConfig.override;
       expect(override).to.not.be.undefined;
       expect(override).to.have.property('chain2');
 
@@ -245,37 +267,39 @@ describe('RebalancerConfig', () => {
     it('should throw when an override references a non-existent chain', () => {
       data = {
         warpRouteId: 'warpRouteId',
-        strategy: {
-          rebalanceStrategy: RebalancerStrategyOptions.MinAmount,
-          chains: {
-            chain1: {
-              minAmount: {
-                min: 1000,
-                target: 1100,
-                type: RebalancerMinAmountType.Absolute,
-              },
-              bridge: ethers.constants.AddressZero,
-              bridgeLockTime: 1,
-              override: {
-                chain2: {
-                  bridge: '0x1234567890123456789012345678901234567890',
+        strategy: [
+          {
+            rebalanceStrategy: RebalancerStrategyOptions.MinAmount,
+            chains: {
+              chain1: {
+                minAmount: {
+                  min: 1000,
+                  target: 1100,
+                  type: RebalancerMinAmountType.Absolute,
                 },
-                chain3: {
-                  bridgeMinAcceptedAmount: 1000,
+                bridge: ethers.constants.AddressZero,
+                bridgeLockTime: 1,
+                override: {
+                  chain2: {
+                    bridge: '0x1234567890123456789012345678901234567890',
+                  },
+                  chain3: {
+                    bridgeMinAcceptedAmount: 1000,
+                  },
                 },
               },
-            },
-            chain2: {
-              minAmount: {
-                min: 2000,
-                target: 2200,
-                type: RebalancerMinAmountType.Absolute,
+              chain2: {
+                minAmount: {
+                  min: 2000,
+                  target: 2200,
+                  type: RebalancerMinAmountType.Absolute,
+                },
+                bridge: ethers.constants.AddressZero,
+                bridgeLockTime: 1,
               },
-              bridge: ethers.constants.AddressZero,
-              bridgeLockTime: 1,
             },
           },
-        },
+        ],
       };
 
       writeYamlOrJson(TEST_CONFIG_PATH, data);
@@ -288,34 +312,36 @@ describe('RebalancerConfig', () => {
     it('should throw when an override references itself', () => {
       data = {
         warpRouteId: 'warpRouteId',
-        strategy: {
-          rebalanceStrategy: RebalancerStrategyOptions.MinAmount,
-          chains: {
-            chain1: {
-              minAmount: {
-                min: 1000,
-                target: 1100,
-                type: RebalancerMinAmountType.Absolute,
-              },
-              bridge: ethers.constants.AddressZero,
-              bridgeLockTime: 1,
-              override: {
-                chain1: {
-                  bridgeMinAcceptedAmount: 1000,
+        strategy: [
+          {
+            rebalanceStrategy: RebalancerStrategyOptions.MinAmount,
+            chains: {
+              chain1: {
+                minAmount: {
+                  min: 1000,
+                  target: 1100,
+                  type: RebalancerMinAmountType.Absolute,
+                },
+                bridge: ethers.constants.AddressZero,
+                bridgeLockTime: 1,
+                override: {
+                  chain1: {
+                    bridgeMinAcceptedAmount: 1000,
+                  },
                 },
               },
-            },
-            chain2: {
-              minAmount: {
-                min: 2000,
-                target: 2200,
-                type: RebalancerMinAmountType.Absolute,
+              chain2: {
+                minAmount: {
+                  min: 2000,
+                  target: 2200,
+                  type: RebalancerMinAmountType.Absolute,
+                },
+                bridge: ethers.constants.AddressZero,
+                bridgeLockTime: 1,
               },
-              bridge: ethers.constants.AddressZero,
-              bridgeLockTime: 1,
             },
           },
-        },
+        ],
       };
 
       writeYamlOrJson(TEST_CONFIG_PATH, data);
@@ -326,7 +352,7 @@ describe('RebalancerConfig', () => {
     });
 
     it('should allow multiple chain overrides', () => {
-      data.strategy.chains.chain1 = {
+      getStrategyArray(data)[0].chains.chain1 = {
         bridge: ethers.constants.AddressZero,
         bridgeMinAcceptedAmount: 3000,
         bridgeLockTime: 1,
@@ -344,7 +370,7 @@ describe('RebalancerConfig', () => {
         },
       };
 
-      data.strategy.chains.chain2 = {
+      getStrategyArray(data)[0].chains.chain2 = {
         bridge: ethers.constants.AddressZero,
         bridgeMinAcceptedAmount: 5000,
         bridgeLockTime: 1,
@@ -354,7 +380,7 @@ describe('RebalancerConfig', () => {
         },
       };
 
-      data.strategy.chains.chain3 = {
+      getStrategyArray(data)[0].chains.chain3 = {
         bridge: ethers.constants.AddressZero,
         bridgeMinAcceptedAmount: 6000,
         bridgeLockTime: 1,
@@ -367,8 +393,8 @@ describe('RebalancerConfig', () => {
       writeYamlOrJson(TEST_CONFIG_PATH, data);
 
       const config = RebalancerConfig.load(TEST_CONFIG_PATH);
-
-      const chain1Overrides = config.strategyConfig.chains.chain1.override;
+      const chainConfig = config.strategyConfig[0].chains.chain1;
+      const chain1Overrides = chainConfig.override;
       expect(chain1Overrides).to.not.be.undefined;
       expect(chain1Overrides).to.have.property('chain2');
       expect(chain1Overrides).to.have.property('chain3');
@@ -384,4 +410,274 @@ describe('RebalancerConfig', () => {
       );
     });
   });
+
+  describe('composite strategy validation', () => {
+    it('should throw if CollateralDeficitStrategy is not first in composite', () => {
+      data = {
+        warpRouteId: 'warpRouteId',
+        strategy: [
+          {
+            rebalanceStrategy: RebalancerStrategyOptions.Weighted,
+            chains: {
+              chain1: {
+                weighted: { weight: 100, tolerance: 0 },
+                bridge: ethers.constants.AddressZero,
+                bridgeLockTime: 1,
+              },
+              chain2: {
+                weighted: { weight: 100, tolerance: 0 },
+                bridge: ethers.constants.AddressZero,
+                bridgeLockTime: 1,
+              },
+            },
+          },
+          {
+            rebalanceStrategy: RebalancerStrategyOptions.CollateralDeficit,
+            chains: {
+              chain1: {
+                buffer: 1000,
+                bridge: ethers.constants.AddressZero,
+                bridgeLockTime: 1,
+              },
+              chain2: {
+                buffer: 1000,
+                bridge: ethers.constants.AddressZero,
+                bridgeLockTime: 1,
+              },
+            },
+          },
+        ],
+      };
+
+      writeYamlOrJson(TEST_CONFIG_PATH, data);
+
+      expect(() => RebalancerConfig.load(TEST_CONFIG_PATH)).to.throw(
+        'CollateralDeficitStrategy must be first when used in composite strategy',
+      );
+    });
+
+    it('should allow CollateralDeficitStrategy first in composite', () => {
+      data = {
+        warpRouteId: 'warpRouteId',
+        strategy: [
+          {
+            rebalanceStrategy: RebalancerStrategyOptions.CollateralDeficit,
+            chains: {
+              chain1: {
+                buffer: 1000,
+                bridge: ethers.constants.AddressZero,
+                bridgeLockTime: 1,
+              },
+              chain2: {
+                buffer: 1000,
+                bridge: ethers.constants.AddressZero,
+                bridgeLockTime: 1,
+              },
+            },
+          },
+          {
+            rebalanceStrategy: RebalancerStrategyOptions.Weighted,
+            chains: {
+              chain1: {
+                weighted: { weight: 100, tolerance: 0 },
+                bridge: ethers.constants.AddressZero,
+                bridgeLockTime: 1,
+              },
+              chain2: {
+                weighted: { weight: 100, tolerance: 0 },
+                bridge: ethers.constants.AddressZero,
+                bridgeLockTime: 1,
+              },
+            },
+          },
+        ],
+      };
+
+      writeYamlOrJson(TEST_CONFIG_PATH, data);
+
+      expect(() => RebalancerConfig.load(TEST_CONFIG_PATH)).to.not.throw();
+    });
+  });
+});
+
+describe('getAllBridges', () => {
+  const BRIDGE_A = '0xAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA';
+  const BRIDGE_B = '0xBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB';
+  const BRIDGE_C = '0xCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC';
+
+  it('should return empty array for empty strategies', () => {
+    const result = getAllBridges([]);
+    expect(result).to.deep.equal([]);
+  });
+
+  it('should return bridge from single strategy', () => {
+    const strategies: StrategyConfig[] = [
+      {
+        rebalanceStrategy: RebalancerStrategyOptions.Weighted,
+        chains: {
+          chain1: {
+            weighted: { weight: 100n, tolerance: 0n },
+            bridge: BRIDGE_A,
+            bridgeLockTime: 1000,
+          },
+          chain2: {
+            weighted: { weight: 100n, tolerance: 0n },
+            bridge: BRIDGE_A,
+            bridgeLockTime: 1000,
+          },
+        },
+      },
+    ];
+
+    const result = getAllBridges(strategies);
+    expect(result).to.deep.equal([BRIDGE_A]);
+  });
+
+  it('should return all bridges from multiple strategies', () => {
+    const strategies: StrategyConfig[] = [
+      {
+        rebalanceStrategy: RebalancerStrategyOptions.CollateralDeficit,
+        chains: {
+          chain1: {
+            buffer: 1000,
+            bridge: BRIDGE_A,
+            bridgeLockTime: 1000,
+          },
+          chain2: {
+            buffer: 1000,
+            bridge: BRIDGE_A,
+            bridgeLockTime: 1000,
+          },
+        },
+      },
+      {
+        rebalanceStrategy: RebalancerStrategyOptions.Weighted,
+        chains: {
+          chain1: {
+            weighted: { weight: 100n, tolerance: 0n },
+            bridge: BRIDGE_B,
+            bridgeLockTime: 1000,
+          },
+          chain2: {
+            weighted: { weight: 100n, tolerance: 0n },
+            bridge: BRIDGE_B,
+            bridgeLockTime: 1000,
+          },
+        },
+      },
+    ];
+
+    const result = getAllBridges(strategies);
+    expect(result).to.have.members([BRIDGE_A, BRIDGE_B]);
+    expect(result).to.have.lengthOf(2);
+  });
+
+  it('should include bridges from per-destination overrides', () => {
+    const strategies: StrategyConfig[] = [
+      {
+        rebalanceStrategy: RebalancerStrategyOptions.Weighted,
+        chains: {
+          chain1: {
+            weighted: { weight: 100n, tolerance: 0n },
+            bridge: BRIDGE_A,
+            bridgeLockTime: 1000,
+            override: {
+              chain2: {
+                bridge: BRIDGE_B,
+              },
+              chain3: {
+                bridge: BRIDGE_C,
+              },
+            },
+          },
+          chain2: {
+            weighted: { weight: 100n, tolerance: 0n },
+            bridge: BRIDGE_A,
+            bridgeLockTime: 1000,
+          },
+          chain3: {
+            weighted: { weight: 100n, tolerance: 0n },
+            bridge: BRIDGE_A,
+            bridgeLockTime: 1000,
+          },
+        },
+      },
+    ];
+
+    const result = getAllBridges(strategies);
+    expect(result).to.have.members([BRIDGE_A, BRIDGE_B, BRIDGE_C]);
+    expect(result).to.have.lengthOf(3);
+  });
+
+  it('should deduplicate bridges across strategies and overrides', () => {
+    const strategies: StrategyConfig[] = [
+      {
+        rebalanceStrategy: RebalancerStrategyOptions.CollateralDeficit,
+        chains: {
+          chain1: {
+            buffer: 1000,
+            bridge: BRIDGE_A,
+            bridgeLockTime: 1000,
+          },
+          chain2: {
+            buffer: 1000,
+            bridge: BRIDGE_B,
+            bridgeLockTime: 1000,
+          },
+        },
+      },
+      {
+        rebalanceStrategy: RebalancerStrategyOptions.Weighted,
+        chains: {
+          chain1: {
+            weighted: { weight: 100n, tolerance: 0n },
+            bridge: BRIDGE_A, // Same as first strategy
+            bridgeLockTime: 1000,
+            override: {
+              chain2: {
+                bridge: BRIDGE_B, // Same as chain2 default
+              },
+            },
+          },
+          chain2: {
+            weighted: { weight: 100n, tolerance: 0n },
+            bridge: BRIDGE_B,
+            bridgeLockTime: 1000,
+          },
+        },
+      },
+    ];
+
+    const result = getAllBridges(strategies);
+    expect(result).to.have.members([BRIDGE_A, BRIDGE_B]);
+    expect(result).to.have.lengthOf(2);
+  });
+
+  it('should handle overrides without bridge property', () => {
+    const strategies: StrategyConfig[] = [
+      {
+        rebalanceStrategy: RebalancerStrategyOptions.Weighted,
+        chains: {
+          chain1: {
+            weighted: { weight: 100n, tolerance: 0n },
+            bridge: BRIDGE_A,
+            bridgeLockTime: 1000,
+            override: {
+              chain2: {
+                bridgeMinAcceptedAmount: 5000, // Override without bridge
+              },
+            },
+          },
+          chain2: {
+            weighted: { weight: 100n, tolerance: 0n },
+            bridge: BRIDGE_A,
+            bridgeLockTime: 1000,
+          },
+        },
+      },
+    ];
+
+    const result = getAllBridges(strategies);
+    expect(result).to.deep.equal([BRIDGE_A]);
+  });
 });