@hyperlane-xyz/rebalancer 0.1.2 → 1.0.0

package/dist/config/RebalancerConfig.test.js

@@ -5,34 +5,41 @@ import { tmpdir } from 'os';
 import { join } from 'path';
 import { writeYamlOrJson } from '@hyperlane-xyz/utils/fs';
 import { RebalancerConfig } from './RebalancerConfig.js';
-import { RebalancerMinAmountType, RebalancerStrategyOptions, } from './types.js';
+import { RebalancerMinAmountType, RebalancerStrategyOptions, 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) {
+    return Array.isArray(data.strategy) ? data.strategy : [data.strategy];
+}
 describe('RebalancerConfig', () => {
     let data;
     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);
     });
@@ -46,31 +53,33 @@ 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);
         expect(() => RebalancerConfig.load(TEST_CONFIG_PATH)).to.throw('No chains configured');
     });
@@ -83,115 +92,122 @@ 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).to.deep.equal({
-            ...data.strategy.chains.chain1,
+        expect(RebalancerConfig.load(TEST_CONFIG_PATH).strategyConfig[0].chains.chain1).to.deep.equal({
+            ...getStrategyArray(data)[0].chains.chain1,
             bridgeLockTime: 1_000,
         });
     });
     it('should load absolute params without modifications', () => {
         data = {
             warpRouteId: 'warpRouteId',
-            strategy: {
-                rebalanceStrategy: RebalancerStrategyOptions.MinAmount,
-                chains: {
-                    chain1: {
-                        minAmount: {
-                            min: '100000',
-                            target: 140000,
-                            type: RebalancerMinAmountType.Absolute,
-                        },
-                        bridge: ethers.constants.AddressZero,
-                        bridgeLockTime: 1,
-                    },
-                    chain2: {
-                        minAmount: {
-                            min: '100000',
-                            target: 140000,
-                            type: RebalancerMinAmountType.Absolute,
-                        },
-                        bridge: ethers.constants.AddressZero,
-                        bridgeLockTime: 1,
-                    },
-                },
-            },
-        };
-        writeYamlOrJson(TEST_CONFIG_PATH, data);
-        expect(RebalancerConfig.load(TEST_CONFIG_PATH).strategyConfig.chains.chain1).to.deep.equal({
-            ...data.strategy.chains.chain1,
-            bridgeLockTime: 1_000,
-        });
-    });
-    describe('override functionality', () => {
-        it('should parse a config with overrides', () => {
-            data = {
-                warpRouteId: 'warpRouteId',
-                strategy: {
+            strategy: [
+                {
                     rebalanceStrategy: RebalancerStrategyOptions.MinAmount,
                     chains: {
                         chain1: {
                             minAmount: {
-                                min: 1000,
-                                target: 1100,
+                                min: '100000',
+                                target: 140000,
                                 type: RebalancerMinAmountType.Absolute,
                             },
                             bridge: ethers.constants.AddressZero,
                             bridgeLockTime: 1,
-                            override: {
-                                chain2: {
-                                    bridge: '0x1234567890123456789012345678901234567890',
-                                },
-                            },
                         },
                         chain2: {
                             minAmount: {
-                                min: 2000,
-                                target: 2200,
+                                min: '100000',
+                                target: 140000,
                                 type: RebalancerMinAmountType.Absolute,
                             },
                             bridge: ethers.constants.AddressZero,
                             bridgeLockTime: 1,
                         },
-                        chain3: {
-                            minAmount: {
-                                min: 3000,
-                                target: 3300,
-                                type: RebalancerMinAmountType.Absolute,
+                    },
+                },
+            ],
+        };
+        writeYamlOrJson(TEST_CONFIG_PATH, data);
+        expect(RebalancerConfig.load(TEST_CONFIG_PATH).strategyConfig[0].chains.chain1).to.deep.equal({
+            ...getStrategyArray(data)[0].chains.chain1,
+            bridgeLockTime: 1_000,
+        });
+    });
+    describe('override functionality', () => {
+        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',
+                                    },
+                                },
+                            },
+                            chain2: {
+                                minAmount: {
+                                    min: 2000,
+                                    target: 2200,
+                                    type: RebalancerMinAmountType.Absolute,
+                                },
+                                bridge: ethers.constants.AddressZero,
+                                bridgeLockTime: 1,
+                            },
+                            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 override = config.strategyConfig.chains.chain1.override;
+            const chainConfig = config.strategyConfig[0].chains.chain1;
+            expect(chainConfig).to.have.property('override');
+            const override = chainConfig.override;
             expect(override).to.not.be.undefined;
             expect(override).to.have.property('chain2');
             const toChain2Override = override.chain2;
@@ -201,37 +217,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);
             expect(() => RebalancerConfig.load(TEST_CONFIG_PATH)).to.throw("Chain 'chain1' has an override for 'chain3', but 'chain3' is not defined in the config");
@@ -239,40 +257,42 @@ 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);
             expect(() => RebalancerConfig.load(TEST_CONFIG_PATH)).to.throw("Chain 'chain1' has an override for 'chain1', but 'chain1' is self-referencing");
         });
         it('should allow multiple chain overrides', () => {
-            data.strategy.chains.chain1 = {
+            getStrategyArray(data)[0].chains.chain1 = {
                 bridge: ethers.constants.AddressZero,
                 bridgeMinAcceptedAmount: 3000,
                 bridgeLockTime: 1,
@@ -289,7 +309,7 @@ describe('RebalancerConfig', () => {
                     },
                 },
             };
-            data.strategy.chains.chain2 = {
+            getStrategyArray(data)[0].chains.chain2 = {
                 bridge: ethers.constants.AddressZero,
                 bridgeMinAcceptedAmount: 5000,
                 bridgeLockTime: 1,
@@ -298,7 +318,7 @@ describe('RebalancerConfig', () => {
                     tolerance: 0,
                 },
             };
-            data.strategy.chains.chain3 = {
+            getStrategyArray(data)[0].chains.chain3 = {
                 bridge: ethers.constants.AddressZero,
                 bridgeMinAcceptedAmount: 6000,
                 bridgeLockTime: 1,
@@ -309,7 +329,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');
@@ -321,5 +342,255 @@ describe('RebalancerConfig', () => {
             expect(chain3Overrides.bridge).to.equal('0x1234567890123456789012345678901234567890');
         });
     });
+    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 = [
+            {
+                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 = [
+            {
+                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 = [
+            {
+                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 = [
+            {
+                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 = [
+            {
+                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]);
+    });
 });
 //# sourceMappingURL=RebalancerConfig.test.js.map