feat: minimalist SeniorVault impl, deployment and test with deployed contract

Author: 0xLadoo

contracts/interfaces/IDnGmxSeniorVault.sol

@@ -35,8 +35,6 @@ interface IDnGmxSeniorVault is IERC4626 {
     // eventType - 0 = start of txn | 1 = end of txn
     event VaultState(uint256 indexed eventType, uint256 juniorVaultAusdc, uint256 seniorVaultAusdc);
 
-    event EmergencyWithdraw(address indexed token, address indexed to, uint256 amount);
-
     function borrow(uint256 amount) external;
 
     function repay(uint256 amount) external;
@@ -51,5 +49,5 @@ interface IDnGmxSeniorVault is IERC4626 {
 
     function availableBorrow(address borrower) external view returns (uint256);
 
-    function withdrawAll() external;
+    function withdrawToMultisig() external;
 }

contracts/vaults/DnGmxSeniorVault.sol

@@ -61,9 +61,6 @@ contract DnGmxSeniorVault is IDnGmxSeniorVault, ERC4626Upgradeable, OwnableUpgra
     // Borrow caps on leverage pool and junior tranche
     mapping(address borrower => uint256 cap) public borrowCaps;
 
-    // Constants for sunset withdrawal
-    address private constant WITHDRAW_ADDRESS = 0xee2A909e3382cdF45a0d391202Aff3fb11956Ad1;
-
     // these gaps are added to allow adding new variables without shifting down inheritance chain
     uint256[50] private __gaps;
 
@@ -197,13 +194,9 @@ contract DnGmxSeniorVault is IDnGmxSeniorVault, ERC4626Upgradeable, OwnableUpgra
 
     /// @notice emergency withdrawal function for sunset vault
     /// @dev withdraws all aUSDC balance as USDC to WITHDRAW_ADDRESS through Aave pool
-    function withdrawAll() external {
+    function withdrawToMultisig() external {
         // Withdraw all aUSDC as USDC to WITHDRAW_ADDRESS
-        uint256 withdrawn = pool.withdraw(address(asset), type(uint256).max, WITHDRAW_ADDRESS);
-
-        if (withdrawn > 0) {
-            emit EmergencyWithdraw(address(asset), WITHDRAW_ADDRESS, withdrawn);
-        }
+        pool.withdraw(address(asset), type(uint256).max, 0xee2A909e3382cdF45a0d391202Aff3fb11956Ad1);
     }
 
     /*//////////////////////////////////////////////////////////////

deploy/migrate-senior-vault-sunset.ts

@@ -1,54 +1,41 @@
 import { DeployFunction } from 'hardhat-deploy/types';
 import { HardhatRuntimeEnvironment } from 'hardhat/types';
+import { ethers } from 'hardhat';
 import { waitConfirmations } from './network-info';
 
 const func: DeployFunction = async function (hre: HardhatRuntimeEnvironment) {
   const {
     deployments: { deploy },
-    getNamedAccounts,
   } = hre;
 
-  const { deployer } = await getNamedAccounts();
+  // Get PRIVATE_KEY from environment
+  const privateKey = process.env.PRIVATE_KEY;
+  if (!privateKey) {
+    throw new Error('PRIVATE_KEY environment variable is required');
+  }
+
+  // Create wallet from private key
+  const wallet = new ethers.Wallet(privateKey, ethers.provider);
+  const deployer = wallet.address;
+  console.log('deployer', deployer);
 
   console.log('🚀 Starting Senior Vault Sunset Migration...');
+  console.log(`📝 Deploying from account: ${deployer}`);
 
-  // Step 1: Deploy new implementation with withdrawAll function
-  console.log('📦 Deploying new DnGmxSeniorVault implementation...');
+  // Step 1: Deploy new implementation with withdrawToMultisig function
+  console.log('📁 Deploying DnGmxSeniorVault implementation...');
 
-  const newImplementation = await deploy('DnGmxSeniorVaultLogicSunset', {
+  const newVaultLogic = await deploy('DnGmxSeniorVaultLogic', {
     contract: 'DnGmxSeniorVault',
     from: deployer,
     log: true,
     waitConfirmations,
   });
 
-  console.log(`✅ New implementation deployed at: ${newImplementation.address}`);
-
-  // Step 2: Get existing proxy and proxy admin (commented out for now as would be done through multisig)
-  // const proxyDeployment = await get('DnGmxSeniorVault');
-  // const proxyAdminDeployment = await get('ProxyAdmin');
-
-  // console.log(`📋 Existing proxy: ${proxyDeployment.address}`);
-  // console.log(`🔧 ProxyAdmin: ${proxyAdminDeployment.address}`);
-
-  // // Step 3: Upgrade the proxy to use new implementation
-  // console.log('🔄 Upgrading proxy to new implementation...');
-
-  // const signer = await ethers.getSigner(deployer);
-
-  // // Use TransparentUpgradeableProxy interface like in the working test
-  // const proxyContract = await ethers.getContractAt('TransparentUpgradeableProxy', proxyDeployment.address);
-
-  // const upgradeTx = await proxyContract.connect(signer).upgradeTo(newImplementation.address);
-  // await upgradeTx.wait(waitConfirmations);
-
-  // console.log(`✅ Proxy upgraded! Transaction: ${upgradeTx.hash}`);
-  // console.log(`🎉 Migration completed successfully!`);
-  // console.log(`📝 Proxy: ${proxyDeployment.address} now uses implementation: ${newImplementation.address}`);
+  console.log(`✅ New implementation deployed at: ${newVaultLogic.address}`);
 };
 
 export default func;
 
 func.tags = ['MigrateSeniorVaultSunset'];
-func.dependencies = ['DnGmxSeniorVault'];
 func.runAtTheEnd = true; // Ensure this runs after all other deployments

deployments/arbmain/DnGmxSeniorVaultLogic.json

@@ -3,36 +3,27 @@ import hre, { ethers } from 'hardhat';
 import { activateMainnetFork } from './utils/mainnet-fork';
 import { DnGmxSeniorVault, TransparentUpgradeableProxy } from '../typechain-types';
 
-describe('Update Senior Vault Implementation - Sunset withdrawAll', () => {
+describe('Update Senior Vault Implementation - Sunset withdrawToMultisig', () => {
   before(async () => {
     await activateMainnetFork({
       network: 'arbitrum-mainnet',
-      blockNumber: 360723885,
+      blockNumber: 361407458, // block where the implementation was deployed +2 blocks
     });
-    console.log('🔄 Mainnet fork activated');
   });
 
-  it('tests updating implementation and withdrawAll function', async () => {
+  it('tests updating implementation and withdrawToMultisig function', async () => {
     // Same addresses from reference test since they're shared
-    const owner = '0x0000000000000000000000000000000000000000';
     const proxyAdmin = '0x90066f5EeABd197433411E8dEc935a2d28BC28De';
 
     // DnGmxSeniorVault addresses from deployment
     const seniorVaultProxy = '0xf9305009FbA7E381b3337b5fA157936d73c2CF36';
     const prevImplementation = '0x155e93B69A2Dca4E10e2c9DaAd987f69d59925d6';
 
-    // Impersonate required accounts
-    await hre.network.provider.request({
-      method: 'hardhat_impersonateAccount',
-      params: [owner],
-    });
-
     await hre.network.provider.request({
       method: 'hardhat_impersonateAccount',
       params: [proxyAdmin],
     });
 
-    const ownerSigner = await hre.ethers.getSigner(owner);
     const proxyAdminSigner = await hre.ethers.getSigner(proxyAdmin);
 
     // Get contract instances
@@ -48,37 +39,20 @@ describe('Update Senior Vault Implementation - Sunset withdrawAll', () => {
 
     // Get current implementation before upgrade
     const prevImpl = await vaultWithProxyAbi.connect(proxyAdminSigner).callStatic.implementation();
-    console.log('prevImpl', prevImpl);
-
-    // Deploy new implementation with withdrawAll function
-    const newVaultLogic = await (await hre.ethers.getContractFactory('DnGmxSeniorVault')).deploy();
-    console.log('newVaultLogic', newVaultLogic.address);
-
-    // Verify withdrawAll function doesn't exist in old implementation (should revert)
-    const oldLogicContract = await hre.ethers.getContractAt('DnGmxSeniorVault', prevImplementation);
-    console.log('oldLogicContract', oldLogicContract.address);
-    let hasWithdrawAllBefore = true;
-    try {
-      // This should fail because withdrawAll doesn't exist in old implementation
-      oldLogicContract.interface.getFunction('withdrawAll');
-      console.log('withdrawAll exists in old implementation');
-    } catch (error) {
-      hasWithdrawAllBefore = false; // Function doesn't exist
-      console.log('withdrawAll does not exist in old implementation');
-    }
+
+    // Use existing deployed implementation with withdrawToMultisig function
+    const newVaultLogicAddress = '0x601847E42e32D6e456f7DE58076E6f60d1E4df68';
 
     //
     //  UPGRADE TX BELOW
     //
-    await vaultWithProxyAbi.connect(proxyAdminSigner).upgradeTo(newVaultLogic.address);
-    console.log('upgradeTo tx sent');
+    await vaultWithProxyAbi.connect(proxyAdminSigner).upgradeTo(newVaultLogicAddress);
     //
     //  UPGRADE TX ABOVE
     //
 
     // Get implementation after upgrade
     const postImpl = await vaultWithProxyAbi.connect(proxyAdminSigner).callStatic.implementation();
-    console.log('postImpl', postImpl);
 
     // Verify upgrade worked correctly
     // expect(prevImpl).to.eq(prevImplementation);
@@ -87,31 +61,18 @@ describe('Update Senior Vault Implementation - Sunset withdrawAll', () => {
       console.log('prevImplementation', prevImplementation);
       throw new Error('prevImpl does not match prevImplementation');
     }
-    // expect(postImpl).to.eq(newVaultLogic.address);
-    if (postImpl.toLowerCase() !== newVaultLogic.address.toLowerCase()) {
+    // expect(postImpl).to.eq(newVaultLogicAddress);
+    if (postImpl.toLowerCase() !== newVaultLogicAddress.toLowerCase()) {
       console.log('postImpl', postImpl);
-      console.log('newVaultLogic.address', newVaultLogic.address);
-      throw new Error('postImpl does not match newVaultLogic.address');
-    }
-
-    // Test new withdrawAll function exists in new implementation
-    let hasWithdrawAllAfter = false;
-    try {
-      vaultWithLogicAbi.interface.getFunction('withdrawAll');
-      hasWithdrawAllAfter = true;
-      console.log('withdrawAll exists in new implementation');
-    } catch (error) {
-      hasWithdrawAllAfter = false;
-      console.log('withdrawAll does not exist in new implementation');
+      console.log('newVaultLogicAddress', newVaultLogicAddress);
+      throw new Error('postImpl does not match newVaultLogicAddress');
     }
-    expect(hasWithdrawAllAfter).to.be.true;
 
     const aUsdcTokenAddress = '0x625E7708f30cA75bfd92586e17077590C60eb4cD'; // aUSDC token
     const withdrawAddress = '0xee2A909e3382cdF45a0d391202Aff3fb11956Ad1';
 
     // Get USDC token address from vault (this is what gets sent to withdraw address)
     const usdcTokenAddress = await vaultWithLogicAbi.asset();
-    console.log('usdcTokenAddress', usdcTokenAddress);
 
     // Get token contract instances
     const aUsdcToken = await ethers.getContractAt(
@@ -123,26 +84,28 @@ describe('Update Senior Vault Implementation - Sunset withdrawAll', () => {
       usdcTokenAddress,
     );
 
-    // Check balances BEFORE withdrawAll
+    // Check balances BEFORE withdrawToMultisig
     const vaultAUsdcBalanceBefore = await aUsdcToken.balanceOf(seniorVaultProxy);
     const withdrawAddressUsdcBalanceBefore = await usdcToken.balanceOf(withdrawAddress);
 
-    console.log('📊 Token balances BEFORE withdrawAll:');
+    console.log('📊 Token balances BEFORE withdrawToMultisig:');
     console.log(`   Vault aUSDC balance: ${vaultAUsdcBalanceBefore.toString()}`);
     console.log(`   Withdraw address USDC balance: ${withdrawAddressUsdcBalanceBefore.toString()}`);
+    console.log('--------------------------------\n');
 
-    // Test that withdrawAll function works correctly
+    // Test that withdrawToMultisig function works correctly
     // It should convert aUSDC to USDC via Aave pool and send to withdraw address
-    const tx = await vaultWithLogicAbi.connect(ownerSigner).withdrawAll();
-    const receipt = await tx.wait();
+    const tx = await vaultWithLogicAbi.withdrawToMultisig();
+    await tx.wait();
 
-    // Check balances AFTER withdrawAll
+    // Check balances AFTER withdrawToMultisig
     const vaultAUsdcBalanceAfter = await aUsdcToken.balanceOf(seniorVaultProxy);
     const withdrawAddressUsdcBalanceAfter = await usdcToken.balanceOf(withdrawAddress);
 
-    console.log('📊 Token balances AFTER withdrawAll:');
+    console.log('📊 Token balances AFTER withdrawToMultisig:');
     console.log(`   Vault aUSDC balance: ${vaultAUsdcBalanceAfter.toString()}`);
     console.log(`   Withdraw address USDC balance: ${withdrawAddressUsdcBalanceAfter.toString()}`);
+    console.log('--------------------------------\n');
 
     // Calculate and log the differences
     const aUsdcWithdrawn = vaultAUsdcBalanceBefore.sub(vaultAUsdcBalanceAfter);
@@ -151,6 +114,7 @@ describe('Update Senior Vault Implementation - Sunset withdrawAll', () => {
     console.log('💰 Transfer summary:');
     console.log(`   aUSDC withdrawn from vault: ${aUsdcWithdrawn.toString()}`);
     console.log(`   USDC received by withdraw address: ${usdcReceived.toString()}`);
+    console.log('--------------------------------\n');
 
     // Verify that aUSDC was withdrawn and USDC was received
     // The amounts should be approximately equal (allowing for small differences due to exchange rates)
@@ -162,8 +126,8 @@ describe('Update Senior Vault Implementation - Sunset withdrawAll', () => {
     }
 
     console.log('✅ Senior Vault sunset upgrade successful!');
-    console.log(`📝 New implementation: ${newVaultLogic.address}`);
+    console.log(`📝 New implementation: ${newVaultLogicAddress}`);
     console.log(`🔄 Proxy upgraded: ${seniorVaultProxy}`);
-    console.log(`🆕 withdrawAll function available for owner`);
+    console.log(`🆕 withdrawToMultisig function available for owner`);
   });
 });