tests: warlord zapper

contracts/script/DeployZapper.s.sol

@@ -8,6 +8,8 @@ import "forge-std/Script.sol";
 contract DeployZapper is Script {
     address constant augustusSwapper = 0xDEF171Fe48CF0115B1d80b88dc8eAB59176FEe57;
     address constant tokenTransferAddress = 0x216B4B4Ba9F3e719726886d34a177484278Bfcae;
+    address constant warMinter = 0x144a689A8261F1863c89954930ecae46Bd950341;
+    address constant vault = 0x188cA46Aa2c7ae10C14A931512B62991D5901453;
 
     address owner;
 
@@ -21,7 +23,7 @@ contract DeployZapper is Script {
         address deployer = vm.rememberKey(deployerPrivateKey);
         vm.startBroadcast(deployer);
 
-        Zapper zap = new Zapper(owner, augustusSwapper, tokenTransferAddress);
+        Zapper zap = new Zapper(owner, augustusSwapper, tokenTransferAddress, warMinter, vault);
         console.log("Zap deployed at: %s", address(zap));
 
         vm.stopBroadcast();

contracts/src/Zapper.sol

@@ -87,23 +87,25 @@ contract Zapper is Owned2Step {
     /**
      * @notice Address of the WarMinter contract
      */
-    address public warMinter = 0x144a689A8261F1863c89954930ecae46Bd950341;
+    address public warMinter;
     /**
      * @notice Address of the ERC4626 vault
      */
-    address public vault = 0x188cA46Aa2c7ae10C14A931512B62991D5901453;
+    address public vault;
 
     /*//////////////////////////////////////////////////////////////
                                CONSTRUCTOR
     //////////////////////////////////////////////////////////////*/
 
-    constructor(address initialOwner, address initialSwapRouter, address initialTokenTransferAddress)
+    constructor(address initialOwner, address initialSwapRouter, address initialTokenTransferAddress, address initialWarMinter, address initialVault)
         Owned2Step(initialOwner)
     {
-        if (initialSwapRouter == address(0) || initialTokenTransferAddress == address(0)) revert Errors.ZeroAddress();
+        if (initialSwapRouter == address(0) || initialTokenTransferAddress == address(0) || initialWarMinter == address(0) || initialVault == address(0)) revert Errors.ZeroAddress();
 
         swapRouter = initialSwapRouter;
         tokenTransferAddress = initialTokenTransferAddress;
+        warMinter = initialWarMinter;
+        vault = initialVault;
     }
 
     /*////////////////////////////////////////////
@@ -133,13 +135,13 @@ contract Zapper is Owned2Step {
     ////////////////////////////////////////////*/
 
     /**
-        * @notice Set the WarMinter address
-        * @param newWarMinter address of the WarMinter
+     * @notice Set the WarMinter address
+     * @param newWarMinter address of the WarMinter
      * @custom:requires owner
      */
     function setWarMinter(address newWarMinter) external onlyOwner {
         if (newWarMinter == address(0)) revert Errors.ZeroAddress();
-        
+
         warMinter = newWarMinter;
 
         emit SetWarMinter(newWarMinter);
@@ -295,7 +297,7 @@ contract Zapper is Owned2Step {
      * @param callDatas bytes to call the router/aggregator
      * @return stakedAmount Amount of tWAR staked
      */
-    function zapEtherToSingleToken(address receiver, address vlToken, bytes calldata callDatas)
+    function zapEtherToSingleToken(address vlToken, address receiver, bytes calldata callDatas)
         external
         payable
         returns (uint256 stakedAmount)
@@ -342,7 +344,7 @@ contract Zapper is Owned2Step {
      * @param callDatas bytes to call the router/aggregator
      * @return stakedAmount Amount of tWAR staked
      */
-    function zapEtherToMultipleTokens(address receiver, address[] calldata vlTokens, bytes[] calldata callDatas)
+    function zapEtherToMultipleTokens(address[] calldata vlTokens, address receiver, bytes[] calldata callDatas)
         external
         payable
         returns (uint256 stakedAmount)
@@ -367,9 +369,9 @@ contract Zapper is Owned2Step {
      */
     function zapERC20ToMultipleTokens(
         address token,
+        address[] calldata vlTokens,
         uint256 amount,
         address receiver,
-        address[] calldata vlTokens,
         bytes[] calldata callDatas
     ) external returns (uint256 stakedAmount) {
         if (receiver == address(0)) revert Errors.ZeroAddress();

contracts/test/Zapper/Constructor.t.sol

@@ -0,0 +1,34 @@
+// SPDX-License-Identifier: Unlicensed
+pragma solidity 0.8.20;
+
+import "./ZapperTest.sol";
+
+contract Constructor is ZapperTest {
+    function test_constructor_Normal() public {
+        assertEq(address(zapper.swapRouter()), address(augustusSwapper), "swapRouter is not assigned correctly in constructor");
+        assertEq(address(zapper.owner()), address(owner), "owner is not assigned correctly in constructor");
+        assertEq(address(zapper.vault()), address(vault), "vault is not assigned correctly in constructor");
+        assertEq(address(zapper.warMinter()), address(minter), "warMinter is not assigned correctly in constructor");
+        assertEq(address(zapper.tokenTransferAddress()), address(tokenTransferAddress), "tokenTransferAddress is not assigned correctly in constructor");
+    }
+
+    function test_constructor_ZeroAddressAugustusSwapper() public {
+        vm.expectRevert(Errors.ZeroAddress.selector);
+        new Zapper(address(owner), address(0), address(tokenTransferAddress), address(minter), address(vault));
+    }
+
+    function test_constructor_ZeroAddressTokenTransferAddress() public {
+        vm.expectRevert(Errors.ZeroAddress.selector);
+        new Zapper(address(owner), address(augustusSwapper), address(0), address(minter), address(vault));
+    }
+
+    function test_constructor_ZeroAddressWarMinter() public {
+        vm.expectRevert(Errors.ZeroAddress.selector);
+        new Zapper(address(owner), address(augustusSwapper), address(tokenTransferAddress), address(0), address(vault));
+    }
+
+    function test_constructor_ZeroAddressVault() public {
+        vm.expectRevert(Errors.ZeroAddress.selector);
+        new Zapper(address(owner), address(augustusSwapper), address(tokenTransferAddress), address(minter), address(0));
+    }
+}

contracts/test/Zapper/RemoveWarlordAllowances.t.sol

@@ -0,0 +1,23 @@
+// SPDX-License-Identifier: Unlicensed
+pragma solidity 0.8.20;
+
+import "./ZapperTest.sol";
+
+contract RemoveWarlordAllowances is ZapperTest {
+    function test_removeWarlordAllowances_Normal() public {
+        vm.startPrank(owner);
+        zapper.resetWarlordAllowances();
+
+        assertEq(cvx.allowance(address(zapper), address(minter)), type(uint256).max, "allowance is not set correctly");
+        assertEq(aura.allowance(address(zapper), address(minter)), type(uint256).max, "allowance is not set correctly");
+        assertEq(war.allowance(address(zapper), address(vault)), type(uint256).max, "allowance is not set correctly");
+
+        zapper.removeWarlordAllowances();
+
+        assertEq(cvx.allowance(address(zapper), address(minter)), 0, "allowance is not set correctly");
+        assertEq(aura.allowance(address(zapper), address(minter)), 0, "allowance is not set correctly");
+        assertEq(war.allowance(address(zapper), address(vault)), 0, "allowance is not set correctly");
+
+        vm.stopPrank();
+    }
+}

contracts/test/Zapper/ResetWarlordAllowances.t.sol

@@ -0,0 +1,15 @@
+// SPDX-License-Identifier: Unlicensed
+pragma solidity 0.8.20;
+
+import "./ZapperTest.sol";
+
+contract ResetWarlordAllowances is ZapperTest {
+    function test_resetWarlordAllowances_Normal() public {
+        vm.prank(owner);
+        zapper.resetWarlordAllowances();
+
+        assertEq(cvx.allowance(address(zapper), address(minter)), type(uint256).max, "allowance is not set correctly");
+        assertEq(aura.allowance(address(zapper), address(minter)), type(uint256).max, "allowance is not set correctly");
+        assertEq(war.allowance(address(zapper), address(vault)), type(uint256).max, "allowance is not set correctly");
+    }
+}

contracts/test/Zapper/ZapERC20ToMultipleTokens.sol

@@ -0,0 +1,51 @@
+// SPDX-License-Identifier: Unlicensed
+pragma solidity 0.8.20;
+
+import "./ZapperTest.sol";
+
+contract ZapERC20ToMultipleTokens is ZapperTest {
+    function test_zapERC20ToMultipleTokens_Normal(uint256 erc20Amount, uint256[2] memory tokenAmount) public {
+        erc20Amount = bound(erc20Amount, 1e18, 3000e18);
+        tokenAmount[0] = bound(tokenAmount[0], 1e18, 3000e18);
+        tokenAmount[1] = bound(tokenAmount[1], 1e18, 3000e18);
+
+        bytes[] memory datas = new bytes[](2);
+        address[] memory tokens = new address[](2);
+        tokens[0] = address(aura);
+        tokens[1] = address(cvx);
+
+        uint256 stakerBalance = staker.balanceOf(address(vault));
+
+        deal(address(aura), address(zapper), tokenAmount[0]);
+        deal(address(cvx), address(zapper), tokenAmount[1]);
+        deal(alice, erc20Amount);
+
+        uint256 expectedMintedAmount = ratios.getMintAmount(address(aura), tokenAmount[0]) + ratios.getMintAmount(address(cvx), tokenAmount[1]);
+        uint256 expectedShares = vault.previewDeposit(expectedMintedAmount);
+
+        vm.startPrank(alice);
+
+        usdc.approve(address(zapper), erc20Amount);
+        zapper.zapERC20ToMultipleTokens(address(usdc), tokens, erc20Amount, alice, datas);
+
+        vm.stopPrank();
+
+        assertEqDecimal(aura.balanceOf(address(zapper)), 0, 18, "Vault should have no AURA");
+        assertEqDecimal(cvx.balanceOf(address(zapper)), 0, 18, "Vault should have no CVX");
+        assertEqDecimal(
+            staker.balanceOf(address(vault)), stakerBalance + expectedMintedAmount, 18, "Vault should have same staker balance"
+        );
+        assertEqDecimal(vault.balanceOf(alice), expectedShares, 18, "Alice should have expected shares");
+    }
+
+    function test_zapERC20ToMultipleTokens_ZeroValue(bool tokenSeed) public {
+        bytes[] memory datas = new bytes[](2);
+        address[] memory tokens = new address[](2);
+        tokens[0] = address(aura);
+        tokens[1] = address(cvx);
+
+        vm.prank(alice);
+        vm.expectRevert(Errors.ZeroValue.selector);
+        zapper.zapERC20ToMultipleTokens(address(usdc), tokens, 0, alice, datas);
+    }
+}

contracts/test/Zapper/ZapERC20ToSingleToken.sol

@@ -0,0 +1,44 @@
+// SPDX-License-Identifier: Unlicensed
+pragma solidity 0.8.20;
+
+import "./ZapperTest.sol";
+
+contract ZapERC20ToSingleToken is ZapperTest {
+    function test_zapERC20ToSingleToken_Normal(uint256 erc20amount, uint256 tokenAmount, bool tokenSeed) public {
+        erc20amount = bound(erc20amount, 1e18, 3000e18);
+        tokenAmount = bound(tokenAmount, 1e18, 3000e18);
+
+        bytes memory data = "";
+
+        uint256 stakerBalance = staker.balanceOf(address(vault));
+
+        address token = tokenSeed ? address(aura) : address(cvx);
+        deal(address(token), address(zapper), tokenAmount);
+        deal(address(usdc), alice, erc20amount);
+
+        uint256 expectedMintedAmount = ratios.getMintAmount(token, tokenAmount);
+        uint256 expectedShares = vault.previewDeposit(expectedMintedAmount);
+
+        vm.startPrank(alice);
+
+        usdc.approve(address(zapper), erc20amount);
+        zapper.zapERC20ToSingleToken(address(usdc), address(token), erc20amount, alice, data);
+
+        vm.stopPrank();
+
+        assertEqDecimal(IERC20(token).balanceOf(address(zapper)), 0, 18, "Vault should have no AURA");
+        assertEqDecimal(
+            staker.balanceOf(address(vault)), stakerBalance + expectedMintedAmount, 18, "Vault should have same staker balance"
+        );
+        assertEqDecimal(vault.balanceOf(alice), expectedShares, 18, "Alice should have expected shares");
+    }
+
+    function test_zapERC20ToSingleToken_ZeroValue(bool tokenSeed) public {
+        bytes memory data = "";
+        address token = tokenSeed ? address(aura) : address(cvx);
+
+        vm.prank(alice);
+        vm.expectRevert(Errors.ZeroValue.selector);
+        zapper.zapERC20ToSingleToken(address(usdc), address(token), 0, alice, data);
+    }
+}

contracts/test/Zapper/ZapEtherToMultipleTokens.sol

@@ -0,0 +1,48 @@
+// SPDX-License-Identifier: Unlicensed
+pragma solidity 0.8.20;
+
+import "./ZapperTest.sol";
+
+contract ZapEtherToMultipleTokens is ZapperTest {
+    function test_zapEtherToMultipleTokens_Normal(uint256 etherAmount, uint256[2] memory tokenAmount) public {
+        etherAmount = bound(etherAmount, 1e18, 3000e18);
+        tokenAmount[0] = bound(tokenAmount[0], 1e18, 3000e18);
+        tokenAmount[1] = bound(tokenAmount[1], 1e18, 3000e18);
+
+        bytes[] memory datas = new bytes[](2);
+        address[] memory tokens = new address[](2);
+        tokens[0] = address(aura);
+        tokens[1] = address(cvx);
+
+        uint256 stakerBalance = staker.balanceOf(address(vault));
+
+        deal(address(aura), address(zapper), tokenAmount[0]);
+        deal(address(cvx), address(zapper), tokenAmount[1]);
+        deal(alice, etherAmount);
+
+        uint256 expectedMintedAmount = ratios.getMintAmount(address(aura), tokenAmount[0]) + ratios.getMintAmount(address(cvx), tokenAmount[1]);
+        uint256 expectedShares = vault.previewDeposit(expectedMintedAmount);
+
+        vm.prank(alice);
+        zapper.zapEtherToMultipleTokens{value: etherAmount}(tokens, alice, datas);
+
+
+        assertEqDecimal(aura.balanceOf(address(zapper)), 0, 18, "Vault should have no AURA");
+        assertEqDecimal(cvx.balanceOf(address(zapper)), 0, 18, "Vault should have no CVX");
+        assertEqDecimal(
+            staker.balanceOf(address(vault)), stakerBalance + expectedMintedAmount, 18, "Vault should have same staker balance"
+        );
+        assertEqDecimal(vault.balanceOf(alice), expectedShares, 18, "Alice should have expected shares");
+    }
+
+    function test_zapEtherToMultipleTokens_ZeroValue(bool tokenSeed) public {
+        bytes[] memory datas = new bytes[](2);
+        address[] memory tokens = new address[](2);
+        tokens[0] = address(aura);
+        tokens[1] = address(cvx);
+
+        vm.prank(alice);
+        vm.expectRevert(Errors.ZeroValue.selector);
+        zapper.zapEtherToMultipleTokens{value: 0}(tokens, alice, datas);
+    }
+}

contracts/test/Zapper/ZapEtherToSingleToken.sol

@@ -0,0 +1,41 @@
+// SPDX-License-Identifier: Unlicensed
+pragma solidity 0.8.20;
+
+import "./ZapperTest.sol";
+
+contract ZapEtherToSingleToken is ZapperTest {
+    function test_zapEtherToSingleToken_Normal(uint256 etherAmount, uint256 tokenAmount, bool tokenSeed) public {
+        etherAmount = bound(etherAmount, 1e18, 3000e18);
+        tokenAmount = bound(tokenAmount, 1e18, 3000e18);
+
+        bytes memory data = "";
+
+        uint256 stakerBalance = staker.balanceOf(address(vault));
+
+        address token = tokenSeed ? address(aura) : address(cvx);
+        deal(address(token), address(zapper), tokenAmount);
+        deal(alice, etherAmount);
+
+        uint256 expectedMintedAmount = ratios.getMintAmount(token, tokenAmount);
+        uint256 expectedShares = vault.previewDeposit(expectedMintedAmount);
+
+        vm.prank(alice);
+        zapper.zapEtherToSingleToken{value: etherAmount}(address(token), alice, data);
+
+
+        assertEqDecimal(IERC20(token).balanceOf(address(zapper)), 0, 18, "Vault should have no AURA");
+        assertEqDecimal(
+            staker.balanceOf(address(vault)), stakerBalance + expectedMintedAmount, 18, "Vault should have same staker balance"
+        );
+        assertEqDecimal(vault.balanceOf(alice), expectedShares, 18, "Alice should have expected shares");
+    }
+
+    function test_zapEtherToSingleToken_ZeroValue(bool tokenSeed) public {
+        bytes memory data = "";
+        address token = tokenSeed ? address(aura) : address(cvx);
+
+        vm.prank(alice);
+        vm.expectRevert(Errors.ZeroValue.selector);
+        zapper.zapEtherToSingleToken{value: 0}(address(token), alice, data);
+    }
+}

contracts/test/Zapper/ZapperTest.sol

@@ -0,0 +1,30 @@
+// SPDX-License-Identifier: Unlicensed
+pragma solidity 0.8.20;
+
+import "../Vault/VaultTest.sol";
+import { Zapper } from "../../src/Zapper.sol";
+import { Vault } from "../../src/Vault.sol";
+
+contract ZapperTest is VaultTest {
+    uint256 constant cvxMaxSupply = 100_000_000e18;
+    uint256 constant auraMaxSupply = 100_000_000e18;
+
+    Zapper zapper;
+
+    event ZapHappened(address indexed sender, address indexed receiver, uint256 stakedAmount);
+
+    function setUp() public virtual override {
+        VaultTest.setUp();
+
+        vm.startPrank(owner);
+
+        zapper = new Zapper(owner, augustusSwapper, tokenTransferAddress, address(minter), address(vault));
+
+        zapper.resetWarlordAllowances();
+
+        vm.stopPrank();
+
+        deal(address(weth), address(alice), 10_000e18);
+        deal(address(usdc), address(alice), 10_000e18);
+    }
+}