Vault creation zap

contracts/solidity/testing/MockSushiSwap.sol

@@ -0,0 +1,26 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.0;
+
+
+contract MockSushiSwap {
+
+	function addLiquidity(
+        address tokenA,
+        address tokenB,
+        uint256 amountADesired,
+        uint256 amountBDesired,
+        uint256 amountAMin,
+        uint256 amountBMin,
+        address to,
+        uint256 deadline
+    ) external returns (uint256 amountA, uint256 amountB, uint256 liquidity) {
+		amountA = amountADesired;
+		amountB = amountBDesired;
+		liquidity = (amountADesired * amountBDesired) / 1e18;
+	}
+
+    function factory() external returns (address) {
+        return address(this);
+    }
+}

contracts/solidity/testing/WETH.sol

@@ -0,0 +1,68 @@
+pragma solidity ^0.8.0;
+
+contract WETH {
+    string public name     = "Wrapped Ether";
+    string public symbol   = "WETH";
+    uint8  public decimals = 18;
+
+    event  Approval(address indexed src, address indexed guy, uint wad);
+    event  Transfer(address indexed src, address indexed dst, uint wad);
+    event  Deposit(address indexed dst, uint wad);
+    event  Withdrawal(address indexed src, uint wad);
+
+    mapping (address => uint)                       public  balanceOf;
+    mapping (address => mapping (address => uint))  public  allowance;
+
+    receive() external payable {
+        deposit();
+    }
+
+    function mint(address to, uint256 amount) public {
+        balanceOf[to] += amount;
+    }
+
+    function deposit() public payable {
+        balanceOf[msg.sender] += msg.value;
+        emit Deposit(msg.sender, msg.value);
+    }
+
+    function withdraw(uint wad) public payable {
+        require(balanceOf[msg.sender] >= wad);
+        balanceOf[msg.sender] -= wad;
+        payable(msg.sender).transfer(wad);
+        emit Withdrawal(msg.sender, wad);
+    }
+
+    function totalSupply() public view returns (uint) {
+        return address(this).balance;
+    }
+
+    function approve(address guy, uint wad) public returns (bool) {
+        allowance[msg.sender][guy] = wad;
+        emit Approval(msg.sender, guy, wad);
+        return true;
+    }
+
+    function transfer(address dst, uint wad) public returns (bool) {
+        return transferFrom(msg.sender, dst, wad);
+    }
+
+    function transferFrom(address src, address dst, uint wad)
+        public
+        returns (bool)
+    {
+        require(balanceOf[src] >= wad);
+
+        if (src != msg.sender && allowance[src][msg.sender] >= 0) {
+            require(allowance[src][msg.sender] >= wad);
+            allowance[src][msg.sender] -= wad;
+        }
+
+        balanceOf[src] -= wad;
+        balanceOf[dst] += wad;
+
+        emit Transfer(src, dst, wad);
+
+        return true;
+    }
+}

contracts/solidity/util/SushiHelper.sol

@@ -0,0 +1,37 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.0;
+
+
+contract SushiHelper {
+
+  /**
+   * @notice Calculates the CREATE2 address for a sushi pair without making any
+   * external calls.
+   * 
+   * @return pair Address of our token pair
+   */
+
+  function pairFor(address sushiRouterFactory, address tokenA, address tokenB) external view returns (address pair) {
+    (address token0, address token1) = sortTokens(tokenA, tokenB);
+    pair = address(uint160(uint256(keccak256(abi.encodePacked(
+      hex'ff',
+      sushiRouterFactory,
+      keccak256(abi.encodePacked(token0, token1)),
+      hex'e18a34eb0e04b04f7a0ac29a6e80748dca96319b42c54d679cb821dca90c6303' // init code hash
+    )))));
+  }
+
+
+  /**
+   * @notice Returns sorted token addresses, used to handle return values from pairs sorted in
+   * this order.
+   */
+
+  function sortTokens(address tokenA, address tokenB) internal pure returns (address token0, address token1) {
+      require(tokenA != tokenB, 'UniswapV2Library: IDENTICAL_ADDRESSES');
+      (token0, token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA);
+      require(token0 != address(0), 'UniswapV2Library: ZERO_ADDRESS');
+  }
+
+}