Umami vaults use non-standard deposit function (#456)

- Create a test and figure out why it is not working

Author: miohtama

contracts/guard/src/GuardV0Base.sol

@@ -665,7 +665,8 @@ abstract contract GuardV0Base is IGuard,  Multicall, SwapCowSwap  {
      * - Callsites for deposits and redemptions
      * - Vault share and denomination tokens
      * - Any ERC-4626 extensions are not supported by this function, like special share tokens
-     * - ERC-4626 withdrawal address must be always
+     * - ERC-4626 withdrawal address must be always the Safe
+     * - Because of non-standardisation the whitelisted function list is long
      */
     function whitelistERC4626(address vault, string calldata notes) external {
         IERC4626 vault_ = IERC4626(vault);
@@ -677,6 +678,12 @@ abstract contract GuardV0Base is IGuard,  Multicall, SwapCowSwap  {
         allowCallSite(vault, getSelector("withdraw(uint256,address,address)"), notes);
         allowCallSite(vault, getSelector("redeem(uint256,address,address)"), notes);
 
+        // Umami non-standard ERC-4626
+        // See UmamiDepositManager()
+        // https://arbiscan.io/address/0x959f3807f0aa7921e18c78b00b2819ba91e52fef#code
+        allowCallSite(vault, getSelector("deposit(uint256,uint256,address)"), notes);
+        allowCallSite(vault, getSelector("redeem(uint256,uint256,address,address)"), notes);
+
         // ERC-7540
         // See ERC7540DepositManager
         allowCallSite(vault, getSelector("deposit(uint256,address,address)"), notes);

eth_defi/abi/guard/GuardV0.json

@@ -77,6 +77,7 @@ class RPCRequestError(Exception):
     "block_time": "--block-time",
     "steps_tracing": "--steps-tracing",
     "code_size_limit": "--code-size-limit",
+    "verbose": "-vvvvv",
 }
 
 
@@ -213,6 +214,7 @@ def launch_anvil(
     log_wait=False,
     code_size_limit: int = None,
     rpc_smoke_test=True,
+    verbose=False,
 ) -> AnvilLaunch:
     """Creates Anvil unit test backend or mainnet fork.
 
@@ -390,6 +392,10 @@ def test_anvil_fork_transfer_busd(web3: Web3, large_busd_holder: HexAddress, use
     :parma log_wait:
         Display info level logging while waiting for Anvil to start.
 
+    :param verbose:
+        Make Anvil the proces to dump a lot of stuff to stdout/stderr.
+
+        See -vvvv https://getfoundry.sh/anvil/reference/anvil
     """
 
     attempts_left = attempts
@@ -437,6 +443,7 @@ def test_anvil_fork_transfer_busd(web3: Web3, large_busd_holder: HexAddress, use
         hardfork=hardfork,
         gas_limit=gas_limit,
         steps_tracing=steps_tracing,
+        verbose=verbose,
     )
 
     if code_size_limit:

eth_defi/abi/guard/SimpleVaultV0.json

@@ -1,13 +1,18 @@
 """Umami gmUSDC vault support."""
 
 import datetime
+from decimal import Decimal
 from functools import cached_property
 import logging
 
 from web3.contract import Contract
+
 from eth_typing import BlockIdentifier
+from eth_typing import HexAddress
 
 from eth_defi.erc_4626.core import get_deployed_erc_4626_contract
+from eth_defi.erc_4626.deposit_redeem import ERC4626DepositManager, ERC4626DepositRequest
+from eth_defi.erc_4626.flow import deposit_4626
 from eth_defi.erc_4626.vault import ERC4626Vault
 from eth_defi.vault.base import VaultTechnicalRisk
 
@@ -21,6 +26,8 @@ class UmamiVault(ERC4626Vault):
 
     Umami vaults do not have open source Github repository, developer documentation or easy developer access for integrations,
     making it not recommended to deal with them.
+
+    - Vault smart contract code: https://arbiscan.io/address/0x959f3807f0aa7921e18c78b00b2819ba91e52fef#code
     """
 
     def get_risk(self) -> VaultTechnicalRisk | None:
@@ -63,3 +70,143 @@ def get_performance_fee(self, block_identifier: BlockIdentifier) -> float | None
 
     def get_estimated_lock_up(self) -> datetime.timedelta:
         return datetime.timedelta(days=3)
+
+    def get_deposit_manager(self) -> "eth_defi.umami.vault.UmamiDepositManager":
+        return UmamiDepositManager(self)
+
+
+class UmamiDepositManager(ERC4626DepositManager):
+    """Umami deposit manager with custom logic."""
+
+    def create_deposit_request(
+        self,
+        owner: HexAddress,
+        to: HexAddress = None,
+        amount: Decimal = None,
+        raw_amount: int = None,
+        check_max_deposit=True,
+        check_enough_token=True,
+        max_slippage=0.01,
+        gas=30_000_000,
+    ) -> ERC4626DepositRequest:
+        """Umami has a slippage tolerance on deposits.
+
+        - Umami has a 0.15% deposit fee taken from the shares minted.
+        - Umami deposit is gas hungry
+        - Umami deposit must have ETH attached to the transaction as something spends it there
+
+        .. code-block:: solidity
+
+            // DEPOSIT & WITHDRAW
+            // ------------------------------------------------------------------------------------------
+
+            /**
+             * @notice Deposit a specified amount of assets and mint corresponding shares to the receiver
+             * @param assets The amount of assets to deposit
+             * @param minOutAfterFees Minimum amount out after fees
+             * @param receiver The address to receive the minted shares
+             * @return shares The estimate amount of shares minted for the deposited assets
+             */
+            function deposit(uint256 assets, uint256 minOutAfterFees, address receiver)
+                public
+                payable
+                override
+                whenDepositNotPaused
+                nonReentrant
+                returns (uint256 shares)
+            {
+                // Check for rounding error since we round down in previewDeposit.
+                require((shares = previewDeposit(assets)) != 0, "ZERO_SHARES");
+                require(
+                    totalAssets() + assets <= previewVaultCap() + asset.balanceOf(address(this)), "AssetVault: over vault cap"
+                );
+                // Transfer assets to aggregate vault, transfer before minting or ERC777s could reenter.
+                asset.safeTransferFrom(msg.sender, address(this), assets);
+                aggregateVault.handleDeposit{ value: msg.value }(assets, minOutAfterFees, receiver, msg.sender, address(0));
+
+                emit Deposit(msg.sender, receiver, assets, shares);
+            }
+
+        ETH spend:
+
+        .. code-block:: solidity
+
+            /**
+             * @notice Handles a deposit of a specified amount of an ERC20 asset into the AggregateVault from an account, with a deposit fee deducted.
+             * @param assets The amount of the asset to be deposited.
+             * @param account The address of the account from which the deposit will be made.
+             */
+            function handleDeposit(uint256 assets, uint256 minOutAfterFees, address account, address sender, address callback)
+                external
+                payable
+                onlyAssetVault
+            {
+                if (assets == 0) revert AmountEqualsZero();
+                if (account == address(0)) revert ZeroAddress();
+                AVStorage storage stg = _getStorage();
+                uint256 gas = _gasRequirement(callback != address(0));
+                if (msg.value < gas * tx.gasprice) revert MinGasRequirement();
+
+                // store request data
+                uint256 key = _saveRequest(sender, account, msg.sender, callback, true, assets, minOutAfterFees);
+
+                // send execution gas cost
+                TransferUtils.transferNativeAsset(stg.rebalanceKeeper, msg.value);
+
+                _executeHook(HookType.DEPOSIT_HOOK, msg.data[4:]);
+
+                // emit request event
+                Emitter(stg.emitter).emitDepositRequest(key, account, msg.sender);
+            }
+        """
+
+        if not raw_amount:
+            raw_amount = self.vault.denomination_token.convert_to_raw(amount)
+
+        vault = self.vault
+        from_ = owner
+        receiver = owner
+
+        logger.info(
+            "Depositing to vault %s, amount %s, raw amount %s, from %s",
+            vault.address,
+            amount,
+            raw_amount,
+            from_,
+        )
+
+        preview_amount = vault.vault_contract.functions.previewDeposit(raw_amount).call()
+        estimated_shares = vault.share_token.convert_to_decimals(preview_amount)
+
+        min_shares = int(preview_amount * (1 - max_slippage))
+
+        logger.info("Estimated %s shares before slippage: %s, slippage set to %s, min amount out %s", vault.share_token.symbol, estimated_shares, max_slippage, min_shares)
+
+        contract = vault.vault_contract
+
+        if not raw_amount:
+            assert isinstance(amount, Decimal)
+            assert amount > 0
+            raw_amount = vault.denomination_token.convert_to_raw(amount)
+
+        if check_enough_token:
+            actual_balance_raw = vault.denomination_token.fetch_raw_balance_of(from_)
+            assert actual_balance_raw >= raw_amount, f"Not enough token in {from_} to deposit {amount} to {vault.address}, has {actual_balance_raw}, tries to deposit {raw_amount}"
+
+        if check_max_deposit:
+            max_deposit = contract.functions.maxDeposit(receiver).call()
+            if max_deposit != 0:
+                assert raw_amount <= max_deposit, f"Max deposit {max_deposit} is less than {raw_amount}"
+
+        call = contract.functions.deposit(raw_amount, min_shares, receiver)
+
+        return ERC4626DepositRequest(
+            vault=self.vault,
+            owner=owner,
+            to=owner,
+            funcs=[call],
+            amount=amount,
+            raw_amount=raw_amount,
+            gas=gas,
+            value=Decimal(0.1),
+        )

eth_defi/abi/safe-integration/TradingStrategyModuleV0.json

@@ -4,6 +4,8 @@
 from abc import ABC, abstractmethod
 from dataclasses import dataclass
 from decimal import Decimal
+import logging
+from pprint import pformat
 
 from web3 import Web3
 from web3.contract.contract import ContractFunction
@@ -15,6 +17,9 @@
 from eth_defi.trace import assert_transaction_success_with_explanation
 
 
+logger = logging.getLogger(__name__)
+
+
 class VaultTransactionFailed(Exception):
     """One of vault deposit/redeem transactions reverted"""
 
@@ -216,6 +221,12 @@ class DepositRequest:
     #: It's a list because for Gains we need 2 tx
     funcs: list[ContractFunction]
 
+    #: Set transaction gas limit
+    gas: int | None = None
+
+    #: Attached ETH value to the tx
+    value: Decimal | None = None
+
     def __post_init__(self):
         from eth_defi.vault.base import VaultBase
 
@@ -261,7 +272,7 @@ def parse_deposit_transaction(
 
         return DepositTicket(vault_address=self.vault.address, owner=self.owner, to=self.to, raw_amount=self.raw_amount, tx_hash=tx_hash, gas_used=gas_used, block_timestamp=block_timestamp, block_number=block_number)
 
-    def broadcast(self, from_: HexAddress = None, gas: int = 1_000_000) -> RedemptionTicket:
+    def broadcast(self, from_: HexAddress = None, gas: int | None = None, check_value=True) -> RedemptionTicket:
         """Broadcast all the transactions in this request.
 
         :param from_:
@@ -280,11 +291,37 @@ def broadcast(self, from_: HexAddress = None, gas: int = 1_000_000) -> Redemptio
         if from_ is None:
             from_ = self.owner
 
+        if gas is None:
+            if self.gas:
+                gas = self.gas
+            else:
+                # Default to 1M
+                gas = 1_000_000
+
+        tx_data = {"from": from_, "gas": gas}
+        if self.value:
+            tx_data["value"] = Web3.to_wei(self.value, "ether")
+
+            # If we ask for value, make sure our account is topped up
+            if check_value:
+                balance = self.web3.eth.get_balance(from_)
+                assert balance >= tx_data["value"], f"Not enough ETH balance in {from_} to cover value {self.value} ETH, has {Web3.from_wei(balance, 'ether')} ETH"
+
+        logger.info(
+            "Broadcasting deposit request to vault %s from %s with gas %s and tx params:\n%s",
+            self.vault.address,
+            from_,
+            gas,
+            pformat(tx_data),
+        )
+
         tx_hashes = []
         for func in self.funcs:
-            tx_hash = func.transact({"from": from_, "gas": gas})
+            tx_hash = func.transact(tx_data)
+
             assert_transaction_success_with_explanation(self.web3, tx_hash)
             tx_hashes.append(tx_hash)
+
         return self.parse_deposit_transaction(tx_hashes)