@hyperlane-xyz/sdk 19.5.0 → 19.6.0

package/dist/token/EvmERC20WarpModule.hardhat-test.js

@@ -4,18 +4,19 @@ import { ethers } from 'ethers';
 import hre from 'hardhat';
 import sinon from 'sinon';
 import { UINT_256_MAX } from 'starknet';
-import { CONTRACTS_PACKAGE_VERSION, ERC20Test__factory, ERC4626Test__factory, HypERC20__factory, HypERC4626Collateral__factory, HypNative__factory, MailboxClient__factory, Mailbox__factory, MovableCollateralRouter__factory, } from '@hyperlane-xyz/core';
-import { EvmIsmModule, HookType, IsmType, TestChainName, proxyAdmin, proxyImplementation, serializeContracts, } from '@hyperlane-xyz/sdk';
-import { addressToBytes32, assert, deepCopy, eqAddress, normalizeAddressEvm, randomInt, } from '@hyperlane-xyz/utils';
+import { CONTRACTS_PACKAGE_VERSION, ERC20Test__factory, ERC4626Test__factory, HypERC20__factory, HypERC4626Collateral__factory, HypNative__factory, MailboxClient__factory, Mailbox__factory, MockEverclearAdapter__factory, MovableCollateralRouter__factory, } from '@hyperlane-xyz/core';
+import { EvmIsmModule, HookType, IsmType, TestChainName, TokenFeeType, proxyAdmin, proxyImplementation, serializeContracts, } from '@hyperlane-xyz/sdk';
+import { addressToBytes32, assert, deepCopy, eqAddress, normalizeAddressEvm, objMap, randomInt, } from '@hyperlane-xyz/utils';
 import { TestCoreDeployer } from '../core/TestCoreDeployer.js';
 import { HyperlaneProxyFactoryDeployer } from '../deploy/HyperlaneProxyFactoryDeployer.js';
+import { BPS } from '../fee/EvmTokenFeeReader.hardhat-test.js';
 import { HyperlaneIsmFactory } from '../ism/HyperlaneIsmFactory.js';
 import { MultiProvider } from '../providers/MultiProvider.js';
 import { randomAddress } from '../test/testUtils.js';
 import { normalizeConfig } from '../utils/ism.js';
 import { EvmERC20WarpModule } from './EvmERC20WarpModule.js';
 import { TokenType, isMovableCollateralTokenType, } from './config.js';
-import { HypTokenRouterConfigSchema, derivedHookAddress, isMovableCollateralTokenConfig, } from './types.js';
+import { HypTokenRouterConfigSchema, derivedHookAddress, isEverclearTokenBridgeConfig, isMovableCollateralTokenConfig, } from './types.js';
 chai.use(chaiAsPromised);
 const { expect } = chai;
 const randomRemoteRouters = (n) => {
@@ -32,6 +33,7 @@ describe('EvmERC20WarpHyperlaneModule', async () => {
     const TOKEN_SUPPLY = '100000000000000000000';
     const TOKEN_DECIMALS = 18;
     const chain = TestChainName.test4;
+    const domainId = 31337;
     let mailbox;
     let ismAddress;
     let ismFactory;
@@ -41,6 +43,9 @@ describe('EvmERC20WarpHyperlaneModule', async () => {
     let vaultFactory;
     let vault;
     let token;
+    let feeToken;
+    let everclearBridgeAdapterMockFactory;
+    let everclearBridgeAdapterMock;
     let signer;
     let multiProvider;
     let coreApp;
@@ -66,13 +71,21 @@ describe('EvmERC20WarpHyperlaneModule', async () => {
         routerConfigMap = coreApp.getRouterConfig(signer.address);
         erc20Factory = new ERC20Test__factory(signer);
         token = await erc20Factory.deploy(TOKEN_NAME, TOKEN_NAME, TOKEN_SUPPLY, TOKEN_DECIMALS);
+        feeToken = await erc20Factory.deploy(TOKEN_NAME, TOKEN_NAME, TOKEN_SUPPLY, TOKEN_DECIMALS);
         vaultFactory = new ERC4626Test__factory(signer);
         vault = await vaultFactory.deploy(token.address, TOKEN_NAME, TOKEN_NAME);
         baseConfig = routerConfigMap[chain];
         mailbox = Mailbox__factory.connect(baseConfig.mailbox, signer);
         ismAddress = await mailbox.defaultIsm();
+        everclearBridgeAdapterMockFactory = new MockEverclearAdapter__factory(signer);
+        everclearBridgeAdapterMock =
+            await everclearBridgeAdapterMockFactory.deploy();
     });
     const movableCollateralTypes = Object.values(TokenType).filter(isMovableCollateralTokenType);
+    const everclearTokenBridgeTypes = [
+        TokenType.ethEverclear,
+        TokenType.collateralEverclear,
+    ];
     const assertAllowedRebalancers = async (evmERC20WarpModule, expectedRebalancers) => {
         const currentConfig = await evmERC20WarpModule.read();
         if (isMovableCollateralTokenConfig(currentConfig)) {
@@ -89,18 +102,6 @@ describe('EvmERC20WarpHyperlaneModule', async () => {
                 token: token.address,
                 allowedRebalancers,
             },
-            [TokenType.collateralVault]: {
-                ...baseConfig,
-                type: TokenType.collateralVault,
-                token: vault.address,
-                allowedRebalancers,
-            },
-            [TokenType.collateralVaultRebase]: {
-                ...baseConfig,
-                type: TokenType.collateralVaultRebase,
-                token: vault.address,
-                allowedRebalancers,
-            },
             [TokenType.native]: {
                 ...baseConfig,
                 type: TokenType.native,
@@ -113,6 +114,42 @@ describe('EvmERC20WarpHyperlaneModule', async () => {
             },
         };
     };
+    const getEverclearTokenBridgeTokenConfig = () => {
+        const chainId = multiProvider.getChainId(chain);
+        const everclearFeeParams = {
+            [chainId]: {
+                deadline: Date.now(),
+                fee: randomInt(1000),
+                signature: '0x',
+            },
+        };
+        // Need to "enroll" otherwise the fee won't be set
+        const remoteRouters = {
+            [chainId]: {
+                address: randomAddress(),
+            },
+        };
+        return {
+            [TokenType.collateralEverclear]: {
+                type: TokenType.collateralEverclear,
+                token: token.address,
+                ...baseConfig,
+                everclearBridgeAddress: everclearBridgeAdapterMock.address,
+                everclearFeeParams,
+                outputAssets: {},
+                remoteRouters,
+            },
+            [TokenType.ethEverclear]: {
+                type: TokenType.ethEverclear,
+                wethAddress: token.address,
+                ...baseConfig,
+                everclearBridgeAddress: everclearBridgeAdapterMock.address,
+                everclearFeeParams,
+                outputAssets: {},
+                remoteRouters,
+            },
+        };
+    };
     it('should create with a collateral config', async () => {
         const config = {
             ...baseConfig,
@@ -233,6 +270,66 @@ describe('EvmERC20WarpHyperlaneModule', async () => {
             await assertAllowedRebalancers(evmERC20WarpModule, expectedRebalancers);
         });
     }
+    for (const tokenType of everclearTokenBridgeTypes) {
+        it(`should create ${tokenType} token`, async () => {
+            const config = getEverclearTokenBridgeTokenConfig()[tokenType];
+            // Deploy using WarpModule
+            const evmERC20WarpModule = await EvmERC20WarpModule.create({
+                chain,
+                config,
+                multiProvider,
+                proxyFactoryFactories: ismFactoryAddresses,
+            });
+            const currentConfig = await evmERC20WarpModule.read();
+            assert(isEverclearTokenBridgeConfig(currentConfig), `Expected token of type ${tokenType}`);
+            expect(currentConfig.everclearBridgeAddress).to.deep.equal(config.everclearBridgeAddress);
+            expect(currentConfig.everclearFeeParams).to.deep.equal(config.everclearFeeParams);
+        });
+        it(`should deploy with multiple output assets and fee setting when the token is of type ${tokenType}`, async () => {
+            const baseConfig = getEverclearTokenBridgeTokenConfig()[tokenType];
+            const domainId1 = randomInt(100, 10);
+            const domainId2 = randomInt(1000, 100);
+            const updatedConfig = {
+                ...baseConfig,
+                remoteRouters: {
+                    [domainId1]: {
+                        address: randomAddress(),
+                    },
+                    [domainId2]: {
+                        address: randomAddress(),
+                    },
+                },
+                everclearFeeParams: {
+                    [domainId1]: {
+                        signature: '0x10',
+                        deadline: Date.now(),
+                        fee: randomInt(100),
+                    },
+                    [domainId2]: {
+                        signature: '0x10',
+                        deadline: Date.now(),
+                        fee: randomInt(100),
+                    },
+                },
+                outputAssets: {
+                    [domainId1]: addressToBytes32(randomAddress()),
+                    [domainId2]: addressToBytes32(randomAddress()),
+                },
+            };
+            // Deploy using WarpModule
+            const evmERC20WarpModule = await EvmERC20WarpModule.create({
+                chain,
+                config: updatedConfig,
+                multiProvider,
+                proxyFactoryFactories: ismFactoryAddresses,
+            });
+            const currentConfig = await evmERC20WarpModule.read();
+            assert(isEverclearTokenBridgeConfig(currentConfig), `Expected token of type ${tokenType}`);
+            expect(currentConfig.everclearBridgeAddress).to.deep.equal(updatedConfig.everclearBridgeAddress);
+            expect(currentConfig.everclearFeeParams).to.deep.equal(updatedConfig.everclearFeeParams);
+            expect(currentConfig.outputAssets).to.deep.equal(updatedConfig.outputAssets);
+        });
+    }
     describe(EvmERC20WarpModule.prototype.update.name, async () => {
         const owner = randomAddress();
         const ismConfigToUpdate = [
@@ -687,7 +784,6 @@ describe('EvmERC20WarpHyperlaneModule', async () => {
             });
             it(`should add the specified addresses as rebalancing bridges for tokens of type "${tokenType}"`, async () => {
                 const movableTokenConfigs = getMovableTokenConfig();
-                const domainId = 31337;
                 const config = {
                     ...movableTokenConfigs[tokenType],
                     remoteRouters: {
@@ -709,7 +805,7 @@ describe('EvmERC20WarpHyperlaneModule', async () => {
                         [domainId]: [
                             {
                                 bridge: allowedBridgeToAdd,
-                                approvedTokens: [token.address],
+                                approvedTokens: [feeToken.address],
                             },
                         ],
                     },
@@ -720,11 +816,10 @@ describe('EvmERC20WarpHyperlaneModule', async () => {
                 const warpTokenInstance = MovableCollateralRouter__factory.connect(evmERC20WarpModule.serialize().deployedTokenRoute, signer);
                 const check = await warpTokenInstance.callStatic.allowedBridges(domainId);
                 expect(check[0]).to.eql(allowedBridgeToAdd);
-                const allowance = await token.callStatic.allowance(evmERC20WarpModule.serialize().deployedTokenRoute, allowedBridgeToAdd);
+                const allowance = await feeToken.callStatic.allowance(evmERC20WarpModule.serialize().deployedTokenRoute, allowedBridgeToAdd);
                 expect(allowance.toBigInt() === UINT_256_MAX).to.be.true;
             });
             it(`should remove rebalancing bridges for tokens of type "${tokenType}"`, async () => {
-                const domainId = 31337;
                 const allowedBridgeToAdd = normalizeAddressEvm(randomAddress());
                 const config = HypTokenRouterConfigSchema.parse({
                     ...getMovableTokenConfig()[tokenType],
@@ -737,7 +832,7 @@ describe('EvmERC20WarpHyperlaneModule', async () => {
                         [domainId]: [
                             {
                                 bridge: allowedBridgeToAdd,
-                                approvedTokens: [token.address],
+                                approvedTokens: [feeToken.address],
                             },
                         ],
                     },
@@ -763,7 +858,6 @@ describe('EvmERC20WarpHyperlaneModule', async () => {
             });
             it(`should not generate update transactions for the allowed rebalancing bridges if the address is in a different casing when token is of type "${tokenType}"`, async () => {
                 const movableTokenConfigs = getMovableTokenConfig();
-                const domainId = 31337;
                 const allowedBridgeToAdd = normalizeAddressEvm(randomAddress());
                 const config = HypTokenRouterConfigSchema.parse({
                     ...movableTokenConfigs[tokenType],
@@ -776,7 +870,7 @@ describe('EvmERC20WarpHyperlaneModule', async () => {
                         [domainId]: [
                             {
                                 bridge: allowedBridgeToAdd,
-                                approvedTokens: [token.address],
+                                approvedTokens: [feeToken.address],
                             },
                         ],
                     },
@@ -793,7 +887,7 @@ describe('EvmERC20WarpHyperlaneModule', async () => {
                         [domainId]: [
                             {
                                 bridge: allowedBridgeToAdd.toLowerCase(),
-                                approvedTokens: [token.address],
+                                approvedTokens: [feeToken.address],
                             },
                         ],
                     },
@@ -809,7 +903,7 @@ describe('EvmERC20WarpHyperlaneModule', async () => {
                     config: {
                         ...config,
                         remoteRouters: {
-                            31337: {
+                            [domainId]: {
                                 address: remoteRouter,
                             },
                         },
@@ -838,6 +932,276 @@ describe('EvmERC20WarpHyperlaneModule', async () => {
                 }
             });
         }
+        for (const tokenType of everclearTokenBridgeTypes) {
+            it(`should add destination outputAssets if the token is of type ${tokenType}`, async () => {
+                const config = getEverclearTokenBridgeTokenConfig()[tokenType];
+                const evmERC20WarpModule = await EvmERC20WarpModule.create({
+                    chain,
+                    config,
+                    multiProvider,
+                    proxyFactoryFactories: ismFactoryAddresses,
+                });
+                const remoteToken = randomAddress();
+                const txs = await evmERC20WarpModule.update({
+                    ...config,
+                    outputAssets: {
+                        [domainId]: remoteToken,
+                    },
+                });
+                expect(txs.length).to.equal(1);
+                await sendTxs(txs);
+                const currentConfig = await evmERC20WarpModule.read();
+                assert(isEverclearTokenBridgeConfig(currentConfig), `Expected token of type ${tokenType}`);
+                expect(currentConfig.outputAssets[domainId]).to.equal(addressToBytes32(remoteToken));
+            });
+            it(`should overwrite a destination outputAssets if the token is of type ${tokenType} and a destination token already exists for the given destination`, async () => {
+                const config = getEverclearTokenBridgeTokenConfig()[tokenType];
+                const evmERC20WarpModule = await EvmERC20WarpModule.create({
+                    chain,
+                    config: {
+                        ...config,
+                        outputAssets: {
+                            [domainId]: randomAddress(),
+                        },
+                    },
+                    multiProvider,
+                    proxyFactoryFactories: ismFactoryAddresses,
+                });
+                const expectedRemoteOuputToken = randomAddress();
+                const txs = await evmERC20WarpModule.update({
+                    ...config,
+                    outputAssets: {
+                        [domainId]: expectedRemoteOuputToken,
+                    },
+                });
+                expect(txs.length).to.equal(1);
+                await sendTxs(txs);
+                const currentConfig = await evmERC20WarpModule.read();
+                assert(isEverclearTokenBridgeConfig(currentConfig), `Expected token of type ${tokenType}`);
+                expect(currentConfig.outputAssets[domainId]).to.equal(addressToBytes32(expectedRemoteOuputToken));
+            });
+            it(`should remove destination outputAssets if the token is of type ${tokenType} and a config is set`, async () => {
+                const config = getEverclearTokenBridgeTokenConfig()[tokenType];
+                const evmERC20WarpModule = await EvmERC20WarpModule.create({
+                    chain,
+                    config: {
+                        ...config,
+                        outputAssets: {
+                            [domainId]: randomAddress(),
+                        },
+                    },
+                    multiProvider,
+                    proxyFactoryFactories: ismFactoryAddresses,
+                });
+                const txs = await evmERC20WarpModule.update({
+                    ...config,
+                    outputAssets: {},
+                });
+                expect(txs.length).to.equal(1);
+                await sendTxs(txs);
+                const currentConfig = await evmERC20WarpModule.read();
+                assert(isEverclearTokenBridgeConfig(currentConfig), `Expected token of type ${tokenType}`);
+                expect(currentConfig.outputAssets).to.deep.equal({});
+            });
+            it(`should remove 1 outputAsset and leave the others if the token is of type ${tokenType}`, async () => {
+                const config = getEverclearTokenBridgeTokenConfig()[tokenType];
+                const numOfRouters = randomInt(10, 0);
+                const remoteRoutersToKeep = randomRemoteRouters(numOfRouters);
+                const initialRemoteRouters = {
+                    [domainId]: {
+                        address: randomAddress(),
+                    },
+                    ...remoteRoutersToKeep,
+                };
+                const outputAssetsToKeep = objMap(remoteRoutersToKeep, (_domainId, _) => randomAddress());
+                const expectedOutputAssets = objMap(outputAssetsToKeep, (_domainId, address) => addressToBytes32(address));
+                const initialOutputAddresses = {
+                    [domainId]: randomAddress(),
+                    ...outputAssetsToKeep,
+                };
+                const evmERC20WarpModule = await EvmERC20WarpModule.create({
+                    chain,
+                    config: {
+                        ...config,
+                        remoteRouters: initialRemoteRouters,
+                        outputAssets: initialOutputAddresses,
+                    },
+                    multiProvider,
+                    proxyFactoryFactories: ismFactoryAddresses,
+                });
+                const txs = await evmERC20WarpModule.update({
+                    ...config,
+                    remoteRouters: initialRemoteRouters,
+                    outputAssets: outputAssetsToKeep,
+                });
+                expect(txs.length).to.equal(1);
+                await sendTxs(txs);
+                const currentConfig = await evmERC20WarpModule.read();
+                assert(isEverclearTokenBridgeConfig(currentConfig), `Expected token of type ${tokenType}`);
+                expect(currentConfig.outputAssets).to.deep.equal(expectedOutputAssets);
+            });
+            it(`should update the fee params if the token is of type ${tokenType}`, async () => {
+                const config = getEverclearTokenBridgeTokenConfig()[tokenType];
+                const evmERC20WarpModule = await EvmERC20WarpModule.create({
+                    chain,
+                    config,
+                    multiProvider,
+                    proxyFactoryFactories: ismFactoryAddresses,
+                });
+                const expectedEverclearFeeParams = {
+                    [domainId]: {
+                        deadline: Date.now(),
+                        fee: randomInt(100000000, 100),
+                        signature: '0x42',
+                    },
+                };
+                const txs = await evmERC20WarpModule.update({
+                    ...config,
+                    everclearFeeParams: expectedEverclearFeeParams,
+                });
+                expect(txs.length).to.equal(1);
+                await sendTxs(txs);
+                const currentConfig = await evmERC20WarpModule.read();
+                assert(isEverclearTokenBridgeConfig(currentConfig), `Expected token of type ${tokenType}`);
+                expect(currentConfig.everclearFeeParams).to.deep.equal(expectedEverclearFeeParams);
+            });
+            it(`should not generate any update transactions for the fee params if the config did not change and the token is of type ${tokenType}`, async () => {
+                const config = getEverclearTokenBridgeTokenConfig()[tokenType];
+                const expectedEverclearFeeParams = config.everclearFeeParams;
+                const evmERC20WarpModule = await EvmERC20WarpModule.create({
+                    chain,
+                    config,
+                    multiProvider,
+                    proxyFactoryFactories: ismFactoryAddresses,
+                });
+                const txs = await evmERC20WarpModule.update(config);
+                expect(txs.length).to.equal(0);
+                const currentConfig = await evmERC20WarpModule.read();
+                assert(isEverclearTokenBridgeConfig(currentConfig), `Expected token of type ${tokenType}`);
+                expect(currentConfig.everclearFeeParams).to.deep.equal(expectedEverclearFeeParams);
+            });
+            it(`should remove everclear fee params if the token is of type ${tokenType}`, async () => {
+                const config = getEverclearTokenBridgeTokenConfig()[tokenType];
+                const evmERC20WarpModule = await EvmERC20WarpModule.create({
+                    chain,
+                    config,
+                    multiProvider,
+                    proxyFactoryFactories: ismFactoryAddresses,
+                });
+                // Remove the fee params for the enrolled domain
+                const txs = await evmERC20WarpModule.update({
+                    ...config,
+                    everclearFeeParams: {},
+                });
+                expect(txs.length).to.equal(1);
+                await sendTxs(txs);
+                const currentConfig = await evmERC20WarpModule.read();
+                assert(isEverclearTokenBridgeConfig(currentConfig), `Expected token of type ${tokenType}`);
+                expect(currentConfig.everclearFeeParams).to.deep.equal({});
+            });
+            it(`should remove 1 everclear fee param and leave the others if the token is of type ${tokenType}`, async () => {
+                const config = getEverclearTokenBridgeTokenConfig()[tokenType];
+                const numOfRouters = randomInt(10, 0);
+                const remoteRoutersToKeep = randomRemoteRouters(numOfRouters);
+                const initialRemoteRouters = {
+                    [domainId]: {
+                        address: randomAddress(),
+                    },
+                    ...remoteRoutersToKeep,
+                };
+                const feeParamsToKeep = objMap(remoteRoutersToKeep, (_domainId, _) => ({
+                    deadline: Date.now(),
+                    fee: randomInt(1000),
+                    signature: '0x',
+                }));
+                const initialFeeParams = {
+                    [domainId]: {
+                        deadline: Date.now(),
+                        fee: randomInt(1000),
+                        signature: '0x',
+                    },
+                    ...feeParamsToKeep,
+                };
+                const evmERC20WarpModule = await EvmERC20WarpModule.create({
+                    chain,
+                    config: {
+                        ...config,
+                        remoteRouters: initialRemoteRouters,
+                        everclearFeeParams: initialFeeParams,
+                    },
+                    multiProvider,
+                    proxyFactoryFactories: ismFactoryAddresses,
+                });
+                const txs = await evmERC20WarpModule.update({
+                    ...config,
+                    remoteRouters: initialRemoteRouters,
+                    everclearFeeParams: feeParamsToKeep,
+                });
+                expect(txs.length).to.equal(1);
+                await sendTxs(txs);
+                const currentConfig = await evmERC20WarpModule.read();
+                assert(isEverclearTokenBridgeConfig(currentConfig), `Expected token of type ${tokenType}`);
+                expect(currentConfig.everclearFeeParams).to.deep.equal(feeParamsToKeep);
+            });
+            it(`should remove all everclear fee params except for explicitly kept domains if the token is of type ${tokenType}`, async () => {
+                const config = getEverclearTokenBridgeTokenConfig()[tokenType];
+                const domainId1 = randomInt(100, 10);
+                const domainId2 = randomInt(1000, 100);
+                const domainId3 = randomInt(10000, 1000);
+                const initialRemoteRouters = {
+                    [domainId1]: {
+                        address: randomAddress(),
+                    },
+                    [domainId2]: {
+                        address: randomAddress(),
+                    },
+                    [domainId3]: {
+                        address: randomAddress(),
+                    },
+                };
+                const initialFeeParams = {
+                    [domainId1]: {
+                        deadline: Date.now(),
+                        fee: randomInt(1000),
+                        signature: '0x10',
+                    },
+                    [domainId2]: {
+                        deadline: Date.now(),
+                        fee: randomInt(1000),
+                        signature: '0x20',
+                    },
+                    [domainId3]: {
+                        deadline: Date.now(),
+                        fee: randomInt(1000),
+                        signature: '0x30',
+                    },
+                };
+                const evmERC20WarpModule = await EvmERC20WarpModule.create({
+                    chain,
+                    config: {
+                        ...config,
+                        remoteRouters: initialRemoteRouters,
+                        everclearFeeParams: initialFeeParams,
+                    },
+                    multiProvider,
+                    proxyFactoryFactories: ismFactoryAddresses,
+                });
+                // Keep only domainId2
+                const expectedFeeParams = {
+                    [domainId2]: initialFeeParams[domainId2],
+                };
+                const txs = await evmERC20WarpModule.update({
+                    ...config,
+                    remoteRouters: initialRemoteRouters,
+                    everclearFeeParams: expectedFeeParams,
+                });
+                expect(txs.length).to.equal(2);
+                await sendTxs(txs);
+                const currentConfig = await evmERC20WarpModule.read();
+                assert(isEverclearTokenBridgeConfig(currentConfig), `Expected token of type ${tokenType}`);
+                expect(currentConfig.everclearFeeParams).to.deep.equal(expectedFeeParams);
+            });
+        }
         it('Should deploy and upgrade a new warp route', async () => {
             const domain = 3;
             const config = {
@@ -915,6 +1279,32 @@ describe('EvmERC20WarpHyperlaneModule', async () => {
             // Assert
             expect(updatedConfig.contractVersion).to.eq(CONTRACTS_PACKAGE_VERSION);
         });
+        it('should deploy a new fee if one does not exist', async () => {
+            const config = {
+                ...baseConfig,
+                type: TokenType.native,
+            };
+            // Deploy using WarpModule
+            const evmERC20WarpModule = await EvmERC20WarpModule.create({
+                chain,
+                config,
+                multiProvider,
+                proxyFactoryFactories: ismFactoryAddresses,
+            });
+            const actualConfig = await evmERC20WarpModule.read();
+            const expectedConfig = HypTokenRouterConfigSchema.parse({
+                ...actualConfig,
+                tokenFee: {
+                    type: TokenFeeType.LinearFee,
+                    maxFee: 1000000000,
+                    halfAmount: 500000000,
+                    bps: BPS,
+                },
+            });
+            await sendTxs(await evmERC20WarpModule.update(expectedConfig));
+            const updatedConfig = await evmERC20WarpModule.read();
+            expect(updatedConfig.tokenFee?.type).to.equal(expectedConfig.tokenFee?.type);
+        });
     });
 });
 //# sourceMappingURL=EvmERC20WarpModule.hardhat-test.js.map