@hyperlane-xyz/sdk 44.0.1 → 45.0.0

package/dist/ism/types.test.js

@@ -1,8 +1,8 @@
 import { expect } from 'chai';
 import { ethers } from 'ethers';
-import { assert } from '@hyperlane-xyz/utils';
+import { ZERO_ADDRESS_HEX_32, assert } from '@hyperlane-xyz/utils';
 import { RATE_LIMIT_DEFAULT_DURATION_SECONDS } from '../types.js';
-import { AggregationIsmConfigSchema, BlacklistIsmConfigSchema, CompositeIsmConfigSchema, DelayedFlowRouterHookIsmConfigSchema, IsmConfigSchema, IsmType, MAX_SAFE_UINT48, ModuleType, RateLimitedIsmConfigSchema, NetFlowRateLimitedHookIsmConfigSchema, ismTypeToModuleType, } from './types.js';
+import { AggregationIsmConfigSchema, BlacklistIsmConfigSchema, CompositeIsmConfigSchema, CompositeIsmNodeType, DelayedFlowRouterHookIsmConfigSchema, IsmConfigSchema, IsmType, MAX_SAFE_UINT48, ModuleType, RateLimitedIsmConfigSchema, RoutingMessageIdMultisigIsmConfigSchema, NetFlowRateLimitedHookIsmConfigSchema, ismTypeToModuleType, } from './types.js';
 const SOME_ADDRESS = ethers.Wallet.createRandom().address;
 const OTHER_ADDRESS = ethers.Wallet.createRandom().address;
 // Composite ISM (Sealevel-only) wire fields have distinct formats from the
@@ -481,27 +481,147 @@ describe('ModuleType', () => {
         expect(ismTypeToModuleType(IsmType.COMPOSITE)).to.equal(ModuleType.COMPOSITE);
     });
 });
+describe('RoutingMessageIdMultisigIsmConfigSchema', () => {
+    const VALIDATOR_A = '0x' + 'a'.repeat(40);
+    const VALIDATOR_B = '0x' + 'b'.repeat(40);
+    const base = {
+        type: IsmType.ROUTING_MESSAGE_ID_MULTISIG,
+        owner: SEALEVEL_ADDRESS,
+        domains: {
+            ethereum: { validators: [VALIDATOR_A, VALIDATOR_B], threshold: 2 },
+            test2: { validators: [VALIDATOR_A], threshold: 1 },
+        },
+    };
+    it('maps to ModuleType.MESSAGE_ID_MULTISIG', () => {
+        expect(ismTypeToModuleType(IsmType.ROUTING_MESSAGE_ID_MULTISIG)).to.equal(ModuleType.MESSAGE_ID_MULTISIG);
+    });
+    const THRESHOLD_ISSUE = {
+        path: ['domains', 'ethereum', 'threshold'],
+        message: 'Threshold must be between 1 and the number of validators (inclusive)',
+    };
+    const validatorsIssueCases = [
+        {
+            name: 'threshold 0',
+            validators: [VALIDATOR_A],
+            threshold: 0,
+            issues: [THRESHOLD_ISSUE],
+        },
+        {
+            name: 'a threshold greater than the validator count',
+            validators: [VALIDATOR_A],
+            threshold: 2,
+            issues: [THRESHOLD_ISSUE],
+        },
+        {
+            name: 'duplicate validators differing by case',
+            validators: ['0x' + 'ab'.repeat(20), '0x' + 'AB'.repeat(20)],
+            issues: [
+                {
+                    path: ['domains', 'ethereum', 'validators'],
+                    message: `Duplicate validator address: 0x${'AB'.repeat(20)}`,
+                },
+            ],
+        },
+        {
+            name: 'an empty validator set',
+            validators: [],
+            issues: [
+                {
+                    path: ['domains', 'ethereum', 'validators'],
+                    message: 'At least one validator is required',
+                },
+                {
+                    path: ['domains', 'ethereum', 'threshold'],
+                    message: 'Threshold must be between 1 and the number of validators (inclusive)',
+                },
+            ],
+        },
+        {
+            name: 'a non-array validator set',
+            validators: VALIDATOR_A,
+            issues: [
+                {
+                    path: ['domains', 'ethereum', 'validators'],
+                    message: 'Invalid input: expected array, received string',
+                },
+            ],
+        },
+        {
+            name: 'a bad validator address',
+            validators: ['0x1234'],
+            issues: [
+                {
+                    path: ['domains', 'ethereum', 'validators', 0],
+                    message: 'must be a 20-byte (0x + 40 hex chars) address',
+                },
+            ],
+        },
+    ];
+    for (const c of validatorsIssueCases) {
+        it(`reports the exact issue for ${c.name}`, () => {
+            const result = RoutingMessageIdMultisigIsmConfigSchema.safeParse({
+                ...base,
+                domains: {
+                    ethereum: {
+                        validators: c.validators,
+                        threshold: c.threshold ?? 1,
+                    },
+                },
+            });
+            assert(!result.success, 'expected the config to be rejected');
+            expect(result.error.issues.map((i) => ({ path: i.path, message: i.message }))).to.deep.equal(c.issues);
+        });
+    }
+    it('parses via the schema and the top-level IsmConfigSchema union', () => {
+        const direct = RoutingMessageIdMultisigIsmConfigSchema.safeParse(base);
+        expect(direct.success).to.be.true;
+        if (direct.success) {
+            expect(direct.data.domains.ethereum.threshold).to.equal(2);
+        }
+        expect(IsmConfigSchema.safeParse(base).success).to.be.true;
+    });
+    const ownerCases = [
+        { name: 'a base58 Sealevel owner', owner: SEALEVEL_ADDRESS },
+        {
+            name: 'the reader renounced-owner sentinel',
+            owner: ZERO_ADDRESS_HEX_32,
+        },
+    ];
+    for (const c of ownerCases) {
+        it(`parses ${c.name}`, () => {
+            const result = RoutingMessageIdMultisigIsmConfigSchema.safeParse({
+                ...base,
+                owner: c.owner,
+            });
+            assert(result.success, 'expected the config to parse');
+            expect(result.data.owner).to.equal(c.owner);
+        });
+    }
+});
 describe('CompositeIsmConfigSchema', () => {
     const sample = {
         type: IsmType.COMPOSITE,
         owner: SEALEVEL_ADDRESS,
         root: {
-            type: 'aggregation',
+            type: CompositeIsmNodeType.AGGREGATION,
             threshold: 2,
             subIsms: [
-                { type: 'trustedRelayer', relayer: SEALEVEL_ADDRESS },
                 {
-                    type: 'routing',
+                    type: CompositeIsmNodeType.TRUSTED_RELAYER,
+                    relayer: SEALEVEL_ADDRESS,
+                },
+                {
+                    type: CompositeIsmNodeType.ROUTING,
                     domains: {
-                        solanamainnet: { type: 'test', accept: true },
+                        solanamainnet: { type: CompositeIsmNodeType.TEST, accept: true },
                     },
                 },
                 {
-                    type: 'amountRouting',
+                    type: CompositeIsmNodeType.AMOUNT_ROUTING,
                     threshold: '1000000',
-                    lower: { type: 'pausable', paused: false },
+                    lower: { type: CompositeIsmNodeType.PAUSABLE, paused: false },
                     upper: {
-                        type: 'rateLimited',
+                        type: CompositeIsmNodeType.RATE_LIMITED,
                         maxCapacity: '86400',
                         mailbox: SEALEVEL_ADDRESS,
                         recipient: H256_ADDRESS,
@@ -521,7 +641,7 @@ describe('CompositeIsmConfigSchema', () => {
             typeof result.data === 'object' &&
             result.data !== null &&
             'type' in result.data) {
-            expect(result.data.type).to.equal('compositeIsm');
+            expect(result.data.type).to.equal(IsmType.COMPOSITE);
         }
     });
     it('rejects an unknown node type', () => {
@@ -535,18 +655,28 @@ describe('CompositeIsmConfigSchema', () => {
         const tooHigh = {
             ...sample,
             root: {
-                type: 'aggregation',
+                type: CompositeIsmNodeType.AGGREGATION,
                 threshold: 5,
-                subIsms: [{ type: 'trustedRelayer', relayer: SEALEVEL_ADDRESS }],
+                subIsms: [
+                    {
+                        type: CompositeIsmNodeType.TRUSTED_RELAYER,
+                        relayer: SEALEVEL_ADDRESS,
+                    },
+                ],
             },
         };
         expect(CompositeIsmConfigSchema.safeParse(tooHigh).success).to.be.false;
         const tooLow = {
             ...sample,
             root: {
-                type: 'aggregation',
+                type: CompositeIsmNodeType.AGGREGATION,
                 threshold: 0,
-                subIsms: [{ type: 'trustedRelayer', relayer: SEALEVEL_ADDRESS }],
+                subIsms: [
+                    {
+                        type: CompositeIsmNodeType.TRUSTED_RELAYER,
+                        relayer: SEALEVEL_ADDRESS,
+                    },
+                ],
             },
         };
         expect(CompositeIsmConfigSchema.safeParse(tooLow).success).to.be.false;
@@ -555,7 +685,7 @@ describe('CompositeIsmConfigSchema', () => {
         const invalid = {
             ...sample,
             root: {
-                type: 'multisigMessageId',
+                type: CompositeIsmNodeType.MULTISIG_MESSAGE_ID,
                 threshold: 1,
                 validators: [SOME_ADDRESS, '0x' + SOME_ADDRESS.slice(2).toUpperCase()],
             },
@@ -566,7 +696,7 @@ describe('CompositeIsmConfigSchema', () => {
         const invalid = {
             ...sample,
             root: {
-                type: 'multisigMessageId',
+                type: CompositeIsmNodeType.MULTISIG_MESSAGE_ID,
                 threshold: 3,
                 validators: [SOME_ADDRESS, OTHER_ADDRESS],
             },
@@ -577,7 +707,7 @@ describe('CompositeIsmConfigSchema', () => {
         const invalid = {
             ...sample,
             root: {
-                type: 'multisigMessageId',
+                type: CompositeIsmNodeType.MULTISIG_MESSAGE_ID,
                 threshold: 1.5,
                 validators: [SOME_ADDRESS, OTHER_ADDRESS],
             },
@@ -588,51 +718,70 @@ describe('CompositeIsmConfigSchema', () => {
         const invalid = {
             ...sample,
             root: {
-                type: 'multisigMessageId',
+                type: CompositeIsmNodeType.MULTISIG_MESSAGE_ID,
                 threshold: 1,
                 validators: [SEALEVEL_ADDRESS],
             },
         };
         expect(CompositeIsmConfigSchema.safeParse(invalid).success).to.be.false;
     });
-    it('rejects a rateLimited node with a zero mailbox or missing/zero recipient', () => {
+    it('rejects a rateLimited node with a zero mailbox or zero recipient', () => {
         const zeroMailbox = {
             ...sample,
             root: {
-                type: 'rateLimited',
+                type: CompositeIsmNodeType.RATE_LIMITED,
                 maxCapacity: '86400',
                 mailbox: SEALEVEL_ZERO_ADDRESS,
                 recipient: H256_ADDRESS,
             },
         };
         expect(CompositeIsmConfigSchema.safeParse(zeroMailbox).success).to.be.false;
-        const missingRecipient = {
+        const zeroRecipient = {
             ...sample,
             root: {
-                type: 'rateLimited',
+                type: CompositeIsmNodeType.RATE_LIMITED,
                 maxCapacity: '86400',
                 mailbox: SEALEVEL_ADDRESS,
+                recipient: H256_ZERO,
             },
         };
-        expect(CompositeIsmConfigSchema.safeParse(missingRecipient).success).to.be
+        expect(CompositeIsmConfigSchema.safeParse(zeroRecipient).success).to.be
             .false;
-        const zeroRecipient = {
+    });
+    it('accepts a rateLimited node with an omitted recipient', () => {
+        const omittedRecipient = {
             ...sample,
             root: {
-                type: 'rateLimited',
+                type: CompositeIsmNodeType.RATE_LIMITED,
                 maxCapacity: '86400',
                 mailbox: SEALEVEL_ADDRESS,
-                recipient: H256_ZERO,
             },
         };
-        expect(CompositeIsmConfigSchema.safeParse(zeroRecipient).success).to.be
-            .false;
+        expect(CompositeIsmConfigSchema.safeParse(omittedRecipient).success).to.be
+            .true;
+    });
+    it('accepts a rateLimited node nested under a routing domain with an omitted recipient', () => {
+        const omittedRecipient = {
+            ...sample,
+            root: {
+                type: CompositeIsmNodeType.ROUTING,
+                domains: {
+                    ethereum: {
+                        type: CompositeIsmNodeType.RATE_LIMITED,
+                        maxCapacity: '86400',
+                        mailbox: SEALEVEL_ADDRESS,
+                    },
+                },
+            },
+        };
+        expect(CompositeIsmConfigSchema.safeParse(omittedRecipient).success).to.be
+            .true;
     });
     it('rejects a rateLimited node with maxCapacity above u64::MAX', () => {
         const invalid = {
             ...sample,
             root: {
-                type: 'rateLimited',
+                type: CompositeIsmNodeType.RATE_LIMITED,
                 maxCapacity: (2n ** 64n).toString(),
                 mailbox: SEALEVEL_ADDRESS,
                 recipient: H256_ADDRESS,
@@ -644,10 +793,10 @@ describe('CompositeIsmConfigSchema', () => {
         const invalid = {
             ...sample,
             root: {
-                type: 'amountRouting',
+                type: CompositeIsmNodeType.AMOUNT_ROUTING,
                 threshold: (2n ** 256n).toString(),
-                lower: { type: 'test', accept: true },
-                upper: { type: 'test', accept: false },
+                lower: { type: CompositeIsmNodeType.TEST, accept: true },
+                upper: { type: CompositeIsmNodeType.TEST, accept: false },
             },
         };
         expect(CompositeIsmConfigSchema.safeParse(invalid).success).to.be.false;
@@ -657,7 +806,7 @@ describe('CompositeIsmConfigSchema', () => {
             const invalid = {
                 ...sample,
                 root: {
-                    type: 'rateLimited',
+                    type: CompositeIsmNodeType.RATE_LIMITED,
                     maxCapacity: badValue,
                     mailbox: SEALEVEL_ADDRESS,
                     recipient: H256_ADDRESS,
@@ -675,7 +824,7 @@ describe('CompositeIsmConfigSchema', () => {
         const invalidMultisig = {
             ...sample,
             root: {
-                type: 'multisigMessageId',
+                type: CompositeIsmNodeType.MULTISIG_MESSAGE_ID,
                 threshold: 256,
                 validators,
             },
@@ -685,9 +834,14 @@ describe('CompositeIsmConfigSchema', () => {
         const invalidAggregation = {
             ...sample,
             root: {
-                type: 'aggregation',
+                type: CompositeIsmNodeType.AGGREGATION,
                 threshold: 256,
-                subIsms: [{ type: 'trustedRelayer', relayer: SEALEVEL_ADDRESS }],
+                subIsms: [
+                    {
+                        type: CompositeIsmNodeType.TRUSTED_RELAYER,
+                        relayer: SEALEVEL_ADDRESS,
+                    },
+                ],
             },
         };
         expect(CompositeIsmConfigSchema.safeParse(invalidAggregation).success).to.be
@@ -696,14 +850,20 @@ describe('CompositeIsmConfigSchema', () => {
     it('rejects a trustedRelayer node with a zero relayer', () => {
         const invalid = {
             ...sample,
-            root: { type: 'trustedRelayer', relayer: SEALEVEL_ZERO_ADDRESS },
+            root: {
+                type: CompositeIsmNodeType.TRUSTED_RELAYER,
+                relayer: SEALEVEL_ZERO_ADDRESS,
+            },
         };
         expect(CompositeIsmConfigSchema.safeParse(invalid).success).to.be.false;
     });
     it('rejects a trustedRelayer node with an EVM-style hex relayer', () => {
         const invalid = {
             ...sample,
-            root: { type: 'trustedRelayer', relayer: SOME_ADDRESS },
+            root: {
+                type: CompositeIsmNodeType.TRUSTED_RELAYER,
+                relayer: SOME_ADDRESS,
+            },
         };
         expect(CompositeIsmConfigSchema.safeParse(invalid).success).to.be.false;
     });
@@ -712,13 +872,19 @@ describe('CompositeIsmConfigSchema', () => {
         // range, but neither actually decodes to a 32-byte public key.
         const wrongAlphabetDensity = {
             ...sample,
-            root: { type: 'trustedRelayer', relayer: 'z'.repeat(32) },
+            root: {
+                type: CompositeIsmNodeType.TRUSTED_RELAYER,
+                relayer: 'z'.repeat(32),
+            },
         };
         expect(CompositeIsmConfigSchema.safeParse(wrongAlphabetDensity).success).to
             .be.false;
         const wrongWidth = {
             ...sample,
-            root: { type: 'trustedRelayer', relayer: '1'.repeat(33) },
+            root: {
+                type: CompositeIsmNodeType.TRUSTED_RELAYER,
+                relayer: '1'.repeat(33),
+            },
         };
         expect(CompositeIsmConfigSchema.safeParse(wrongWidth).success).to.be.false;
     });
@@ -726,12 +892,12 @@ describe('CompositeIsmConfigSchema', () => {
         const invalid = {
             ...sample,
             root: {
-                type: 'aggregation',
+                type: CompositeIsmNodeType.AGGREGATION,
                 threshold: 1,
                 subIsms: [
-                    { type: 'routing', domains: {} },
+                    { type: CompositeIsmNodeType.ROUTING, domains: {} },
                     {
-                        type: 'fallbackRouting',
+                        type: CompositeIsmNodeType.FALLBACK_ROUTING,
                         fallbackIsm: SEALEVEL_ADDRESS,
                         domains: {},
                     },
@@ -744,7 +910,7 @@ describe('CompositeIsmConfigSchema', () => {
         const invalid = {
             ...sample,
             root: {
-                type: 'fallbackRouting',
+                type: CompositeIsmNodeType.FALLBACK_ROUTING,
                 fallbackIsm: SEALEVEL_ZERO_ADDRESS,
                 domains: {},
             },
@@ -755,15 +921,18 @@ describe('CompositeIsmConfigSchema', () => {
         const invalid = {
             ...sample,
             root: {
-                type: 'aggregation',
+                type: CompositeIsmNodeType.AGGREGATION,
                 threshold: 2,
                 subIsms: [
                     {
-                        type: 'fallbackRouting',
+                        type: CompositeIsmNodeType.FALLBACK_ROUTING,
                         fallbackIsm: SEALEVEL_ADDRESS,
                         domains: {},
                     },
-                    { type: 'trustedRelayer', relayer: SEALEVEL_ADDRESS },
+                    {
+                        type: CompositeIsmNodeType.TRUSTED_RELAYER,
+                        relayer: SEALEVEL_ADDRESS,
+                    },
                 ],
             },
         };
@@ -773,8 +942,10 @@ describe('CompositeIsmConfigSchema', () => {
         const nestedRouting = {
             ...sample,
             root: {
-                type: 'routing',
-                domains: { ethereum: { type: 'routing', domains: {} } },
+                type: CompositeIsmNodeType.ROUTING,
+                domains: {
+                    ethereum: { type: CompositeIsmNodeType.ROUTING, domains: {} },
+                },
             },
         };
         expect(CompositeIsmConfigSchema.safeParse(nestedRouting).success).to.be
@@ -782,10 +953,10 @@ describe('CompositeIsmConfigSchema', () => {
         const nestedFallbackRouting = {
             ...sample,
             root: {
-                type: 'routing',
+                type: CompositeIsmNodeType.ROUTING,
                 domains: {
                     ethereum: {
-                        type: 'fallbackRouting',
+                        type: CompositeIsmNodeType.FALLBACK_ROUTING,
                         fallbackIsm: SEALEVEL_ADDRESS,
                         domains: {},
                     },
@@ -797,8 +968,10 @@ describe('CompositeIsmConfigSchema', () => {
         const nestedPausable = {
             ...sample,
             root: {
-                type: 'routing',
-                domains: { ethereum: { type: 'pausable', paused: false } },
+                type: CompositeIsmNodeType.ROUTING,
+                domains: {
+                    ethereum: { type: CompositeIsmNodeType.PAUSABLE, paused: false },
+                },
             },
         };
         expect(CompositeIsmConfigSchema.safeParse(nestedPausable).success).to.be
@@ -808,10 +981,10 @@ describe('CompositeIsmConfigSchema', () => {
         const valid = {
             ...sample,
             root: {
-                type: 'routing',
+                type: CompositeIsmNodeType.ROUTING,
                 domains: {
                     ethereum: {
-                        type: 'multisigMessageId',
+                        type: CompositeIsmNodeType.MULTISIG_MESSAGE_ID,
                         validators: [SOME_ADDRESS, OTHER_ADDRESS],
                         threshold: 1,
                     },
@@ -823,7 +996,10 @@ describe('CompositeIsmConfigSchema', () => {
     it('accepts a second, distinct base58 pubkey for trustedRelayer', () => {
         const valid = {
             ...sample,
-            root: { type: 'trustedRelayer', relayer: OTHER_SEALEVEL_ADDRESS },
+            root: {
+                type: CompositeIsmNodeType.TRUSTED_RELAYER,
+                relayer: OTHER_SEALEVEL_ADDRESS,
+            },
         };
         expect(CompositeIsmConfigSchema.safeParse(valid).success).to.be.true;
     });