diff --git a/contracts/L2/ETHxPoolV5.sol b/contracts/L2/ETHxPoolV1.sol
similarity index 98%
rename from contracts/L2/ETHxPoolV5.sol
rename to contracts/L2/ETHxPoolV1.sol
index 4eba83d..705c9c5 100644
--- a/contracts/L2/ETHxPoolV5.sol
+++ b/contracts/L2/ETHxPoolV1.sol
@@ -18,7 +18,7 @@ interface AggregatorV3Interface {
         returns (uint80 roundId, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound);
 }
 
-contract ETHxPoolV5 is AccessControlUpgradeable, ReentrancyGuardUpgradeable {
+contract ETHxPoolV1 is AccessControlUpgradeable, ReentrancyGuardUpgradeable {
     using SafeERC20 for IERC20;
 
     /// @notice Role hash of BRIDGER
diff --git a/test/L2/ETHxPoolV5.t.sol b/test/L2/ETHxPoolV1.t.sol
similarity index 71%
rename from test/L2/ETHxPoolV5.t.sol
rename to test/L2/ETHxPoolV1.t.sol
index 5022c2b..ca7ee39 100644
--- a/test/L2/ETHxPoolV5.t.sol
+++ b/test/L2/ETHxPoolV1.t.sol
@@ -2,11 +2,11 @@
 pragma solidity 0.8.22;
 
 import { Test } from "forge-std/Test.sol";
-import { ETHxPoolV5 } from "../../contracts/L2/ETHxPoolV5.sol";
-import { AggregatorV3Interface } from "../../contracts/L2/ETHxPoolV5.sol";
+import { ETHxPoolV1 } from "../../contracts/L2/ETHxPoolV1.sol";
+import { AggregatorV3Interface } from "../../contracts/L2/ETHxPoolV1.sol";
 import { ERC20Mock } from "../mocks/ERC20Mock.sol";
 
-contract ETHxPoolV5Test is Test {
+contract ETHxPoolV1Test is Test {
     uint256 private constant ETHX_RATE = 1 ether;
     uint256 private constant FEE_BPS = 1000;
     address private admin;
@@ -15,7 +15,7 @@ contract ETHxPoolV5Test is Test {
     address private oracle;
     address private ETHx;
 
-    ETHxPoolV5 private eTHxPoolV5;
+    ETHxPoolV1 private eTHxPoolV1;
 
     function setUp() public {
         vm.clearMockedCalls();
@@ -28,40 +28,40 @@ contract ETHxPoolV5Test is Test {
         mockRateOracle(oracle);
         mockErc20(ETHx, "ETHx");
 
-        eTHxPoolV5 = mockETHxPoolV5(pool, admin, bridger, ETHx, FEE_BPS, oracle);
+        eTHxPoolV1 = mockETHxPoolV1(pool, admin, bridger, ETHx, FEE_BPS, oracle);
     }
 
     function testInitialization() public {
-        assertEq(address(eTHxPoolV5.ETHx()), ETHx);
-        assertTrue(eTHxPoolV5.hasRole(keccak256("BRIDGER_ROLE"), bridger));
-        assertTrue(eTHxPoolV5.hasRole(0x0, admin));
+        assertEq(address(eTHxPoolV1.ETHx()), ETHx);
+        assertTrue(eTHxPoolV1.hasRole(keccak256("BRIDGER_ROLE"), bridger));
+        assertTrue(eTHxPoolV1.hasRole(0x0, admin));
     }
 
     function testInitializeDisabled() public {
-        eTHxPoolV5 = new ETHxPoolV5();
+        eTHxPoolV1 = new ETHxPoolV1();
         vm.expectRevert("Initializable: contract is already initialized");
-        eTHxPoolV5.initialize(vm.addr(0x100), vm.addr(0x101), vm.addr(0x102), 9000, vm.addr(0x1001));
+        eTHxPoolV1.initialize(vm.addr(0x100), vm.addr(0x101), vm.addr(0x102), 9000, vm.addr(0x1001));
     }
 
     function testETHxNonZeroAddressRequired() public {
         address pool = vm.addr(0x1003);
         mockProxyDeploy(pool);
-        eTHxPoolV5 = ETHxPoolV5(pool);
-        vm.expectRevert(ETHxPoolV5.ZeroAddress.selector);
-        eTHxPoolV5.initialize(vm.addr(0x100), vm.addr(0x101), vm.addr(0x102), 9000, address(0));
+        eTHxPoolV1 = ETHxPoolV1(pool);
+        vm.expectRevert(ETHxPoolV1.ZeroAddress.selector);
+        eTHxPoolV1.initialize(vm.addr(0x100), vm.addr(0x101), vm.addr(0x102), 9000, address(0));
     }
 
     function testSetFeeBps() public {
         vm.prank(admin);
-        eTHxPoolV5.setFeeBps(FEE_BPS);
-        assertEq(eTHxPoolV5.feeBps(), FEE_BPS);
+        eTHxPoolV1.setFeeBps(FEE_BPS);
+        assertEq(eTHxPoolV1.feeBps(), FEE_BPS);
     }
 
     function testSetFeeInvalidBps(uint256 feeBps) public {
         vm.assume(feeBps > 10_000);
         vm.prank(admin);
-        vm.expectRevert(abi.encodeWithSelector(ETHxPoolV5.InvalidBps.selector));
-        eTHxPoolV5.setFeeBps(feeBps);
+        vm.expectRevert(abi.encodeWithSelector(ETHxPoolV1.InvalidBps.selector));
+        eTHxPoolV1.setFeeBps(feeBps);
     }
 
     function testSetFeeAdminRequired() public {
@@ -70,7 +70,7 @@ contract ETHxPoolV5Test is Test {
         vm.expectRevert(
             "AccessControl: account 0x85e4e16bd367e4259537269633da9a6aa4cf95a3 is missing role 0x0000000000000000000000000000000000000000000000000000000000000000"
         );
-        eTHxPoolV5.setFeeBps(10_000);
+        eTHxPoolV1.setFeeBps(10_000);
     }
 
     function testOracleAdminRequired() public {
@@ -80,26 +80,26 @@ contract ETHxPoolV5Test is Test {
         vm.expectRevert(
             "AccessControl: account 0x85e4e16bd367e4259537269633da9a6aa4cf95a3 is missing role 0x0000000000000000000000000000000000000000000000000000000000000000"
         );
-        eTHxPoolV5.setETHXOracle(oracle_);
+        eTHxPoolV1.setETHXOracle(oracle_);
     }
 
     function testOracleZeroAddressNotAllowed() public {
         address oracle_ = address(0);
         vm.prank(admin);
-        vm.expectRevert(abi.encodeWithSelector(ETHxPoolV5.ZeroAddress.selector));
-        eTHxPoolV5.setETHXOracle(oracle_);
+        vm.expectRevert(abi.encodeWithSelector(ETHxPoolV1.ZeroAddress.selector));
+        eTHxPoolV1.setETHXOracle(oracle_);
     }
 
     function testOracleSetAddress() public {
         vm.prank(admin);
-        eTHxPoolV5.setETHXOracle(oracle);
-        assertEq(eTHxPoolV5.ethxOracle(), oracle);
+        eTHxPoolV1.setETHXOracle(oracle);
+        assertEq(eTHxPoolV1.ethxOracle(), oracle);
     }
 
     function testDepositRequiresNonZeroAmount() public {
         vm.prank(admin);
-        vm.expectRevert(ETHxPoolV5.InvalidAmount.selector);
-        eTHxPoolV5.swapETHToETHx{ value: 0 }("referral");
+        vm.expectRevert(ETHxPoolV1.InvalidAmount.selector);
+        eTHxPoolV1.swapETHToETHx{ value: 0 }("referral");
     }
 
     function testSwapETHForETHx(uint256 ethAmount) public {
@@ -107,19 +107,19 @@ contract ETHxPoolV5Test is Test {
         address user = vm.addr(0x110);
         vm.deal(user, ethAmount);
         vm.prank(admin);
-        ERC20Mock(ETHx).mint(address(eTHxPoolV5), ethAmount);
+        ERC20Mock(ETHx).mint(address(eTHxPoolV1), ethAmount);
         vm.prank(user);
-        eTHxPoolV5.swapETHToETHx{ value: ethAmount }("referral");
+        eTHxPoolV1.swapETHToETHx{ value: ethAmount }("referral");
         uint256 expectedBalance = ethAmount - (ethAmount * FEE_BPS / 10_000);
         assertEq(ERC20Mock(ETHx).balanceOf(user), expectedBalance);
-        (uint256 _amtLessFee,) = eTHxPoolV5.viewSwapETHxAmountAndFee(ethAmount);
+        (uint256 _amtLessFee,) = eTHxPoolV1.viewSwapETHxAmountAndFee(ethAmount);
         assertEq(ERC20Mock(ETHx).balanceOf(user), _amtLessFee);
     }
 
     function testViewSwapETHxAmountAndFee(uint256 ethAmount) public {
         vm.assume(ethAmount > 0.1 ether && ethAmount < 100 ether);
         vm.prank(admin);
-        (uint256 _amt, uint256 _fee) = eTHxPoolV5.viewSwapETHxAmountAndFee(ethAmount);
+        (uint256 _amt, uint256 _fee) = eTHxPoolV1.viewSwapETHxAmountAndFee(ethAmount);
         uint256 expectFee = ethAmount * FEE_BPS / 1e4;
         uint256 expectAmt = (ethAmount - expectFee) * 1e18 / ETHX_RATE;
         assertEq(_fee, expectFee);
@@ -130,16 +130,16 @@ contract ETHxPoolV5Test is Test {
         vm.assume(ethAmount > 0.1 ether && ethAmount < 100 ether);
         address user = vm.addr(0x110);
         vm.prank(admin);
-        ERC20Mock(ETHx).mint(address(eTHxPoolV5), ethAmount);
+        ERC20Mock(ETHx).mint(address(eTHxPoolV1), ethAmount);
         vm.deal(user, ethAmount);
         vm.prank(user);
-        eTHxPoolV5.swapETHToETHx{ value: ethAmount }("referral");
+        eTHxPoolV1.swapETHToETHx{ value: ethAmount }("referral");
         uint256 expectedBalance = ethAmount - (ethAmount * FEE_BPS / 10_000);
         assertEq(ERC20Mock(ETHx).balanceOf(user), expectedBalance);
-        (, uint256 feeAmnt) = eTHxPoolV5.viewSwapETHxAmountAndFee(ethAmount);
+        (, uint256 feeAmnt) = eTHxPoolV1.viewSwapETHxAmountAndFee(ethAmount);
         address _owner = vm.addr(0x111);
         vm.prank(bridger);
-        eTHxPoolV5.withdrawFees(_owner);
+        eTHxPoolV1.withdrawFees(_owner);
         assertEq(_owner.balance, feeAmnt);
     }
 
@@ -147,7 +147,7 @@ contract ETHxPoolV5Test is Test {
         vm.expectRevert(
             "AccessControl: account 0x7fa9385be102ac3eac297483dd6233d62b3e1496 is missing role 0xc809a7fd521f10cdc3c068621a1c61d5fd9bb3f1502a773e53811bc248d919a8"
         );
-        eTHxPoolV5.withdrawFees(vm.addr(0x111));
+        eTHxPoolV1.withdrawFees(vm.addr(0x111));
     }
 
     function testMoveAssetForBridging(uint256 ethAmount) public {
@@ -155,17 +155,17 @@ contract ETHxPoolV5Test is Test {
         vm.prank(admin);
         address user = vm.addr(0x110);
         vm.deal(user, ethAmount);
-        ERC20Mock(ETHx).mint(address(eTHxPoolV5), ethAmount);
+        ERC20Mock(ETHx).mint(address(eTHxPoolV1), ethAmount);
         vm.prank(user);
-        eTHxPoolV5.swapETHToETHx{ value: ethAmount }("referral");
-        uint256 feeEarned = eTHxPoolV5.feeEarnedInETH();
+        eTHxPoolV1.swapETHToETHx{ value: ethAmount }("referral");
+        uint256 feeEarned = eTHxPoolV1.feeEarnedInETH();
         vm.prank(bridger);
-        eTHxPoolV5.withdrawCollectedETH();
+        eTHxPoolV1.withdrawCollectedETH();
         assertEq(bridger.balance, ethAmount - feeEarned);
     }
 
     function mockProxyDeploy(address ethxPool) private {
-        ETHxPoolV5 implementation = new ETHxPoolV5();
+        ETHxPoolV1 implementation = new ETHxPoolV1();
         bytes memory code = address(implementation).code;
         vm.etch(ethxPool, code);
     }
@@ -186,7 +186,7 @@ contract ETHxPoolV5Test is Test {
         vm.etch(ethxMock, code);
     }
 
-    function mockETHxPoolV5(
+    function mockETHxPoolV1(
         address ethxPool,
         address _admin,
         address _bridger,
@@ -195,10 +195,10 @@ contract ETHxPoolV5Test is Test {
         address _ethxOracle
     )
         private
-        returns (ETHxPoolV5 mock_)
+        returns (ETHxPoolV1 mock_)
     {
         mockProxyDeploy(ethxPool);
-        ETHxPoolV5 mock = ETHxPoolV5(ethxPool);
+        ETHxPoolV1 mock = ETHxPoolV1(ethxPool);
         mock.initialize(_admin, _bridger, _ETHx, _feeBps, _ethxOracle);
         return mock;
     }