feat(ethereum): Add erc-4626 claim flow.

- Changelog previously added.

[no changelog]

Author: PrisionMike

common/tests/fixtures/ethereum/sign_tx.json

@@ -6,6 +6,7 @@
     confirm_blob,
     confirm_ethereum_staking_tx,
     confirm_ethereum_vault_tx,
+    confirm_ethereum_vault_claim,
     confirm_text,
     should_show_more,
 )
@@ -290,6 +291,25 @@ async def require_confirm_vault_tx(
         br_name=br_name,
     )
 
+async def require_confirm_claim_rewards(
+        address_n: list[int],
+        maximum_fee: str,
+        fee_info_items: Iterable[StrPropertyType],
+        token_labels: list[str],
+) -> None:
+    account, account_path = get_account_and_path(address_n)
+    token_list = "\n".join(token_labels)
+    await confirm_ethereum_vault_claim(
+        title=TR.ethereum__rewards_claim,
+        intro_question=TR.ethereum__vault_claim_intro,
+        account=account,
+        account_path=account_path,
+        maximum_fee=maximum_fee,
+        info_items=fee_info_items,
+        token_list=token_list,
+        br_name="ethereum/vault/claim",
+    )
+
 
 async def require_confirm_unstake(
     addr_bytes: bytes,

core/src/apps/ethereum/layout.py

@@ -1,5 +1,7 @@
 from ubinascii import unhexlify
 
+from .yielding_vaults import KNOWN_VAULT
+
 KNOWN_ADDRESSES = {
     # https://github.com/LedgerHQ/clear-signing-erc7730-registry/blob/master/registry/1inch/calldata-AggregationRouterV6.json#L9
     unhexlify(
@@ -11,4 +13,5 @@
     unhexlify("68b3465833fb72A70ecDF485E0e4C7bD8665Fc45"): "Uniswap V3 Router",
     # https://etherscan.io/address/0xe592427a0aece92de3edee1f18e0157c05861564
     unhexlify("e592427a0aece92de3edee1f18e0157c05861564"): "Uniswap V3 Router",
+    KNOWN_VAULT[0]: KNOWN_VAULT[2],
 }

core/src/apps/ethereum/sc_constants.py

@@ -237,7 +237,7 @@ async def confirm_tx_data(
         return staking_approver
 
     yielding_approver = yielding.get_approver(
-        msg, network, address_bytes, maximum_fee, fee_items, sender_bytes
+        msg, initial_data, network, address_bytes, maximum_fee, fee_items, sender_bytes
     )
     if yielding_approver is not None:
         if payment_request_verifier is not None:

core/src/apps/ethereum/sign_tx.py

@@ -2,6 +2,7 @@
 
 from trezor.utils import BufferReader
 from trezor.wire import DataError
+from trezor import log
 
 from .yielding_vaults import lookup_vault
 
@@ -19,6 +20,7 @@
 FUNC_SIG_DEPOSIT = b"\x6e\x55\x3f\x65"
 FUNC_SIG_WITHDRAW = b"\xb4\x60\xaf\x94"
 FUNC_SIG_REDEEM = b"\xba\x08\x76\x52"
+FUNC_SIG_CLAIM = b"\x71\xee\x95\xc0"
 
 if __debug__:
     from trezor.crypto.hashlib import sha3_256
@@ -35,33 +37,53 @@
         FUNC_SIG_REDEEM
         == sha3_256(b"redeem(uint256,address,address)", keccak=True).digest()[:4]
     )
-
+    assert (
+        FUNC_SIG_CLAIM
+        == sha3_256(b"claim(address[],address[],uint256[],bytes32[][])", keccak=True).digest()[:4]
+    )
 
 def get_approver(
     msg: MsgInSignTx,
+    initial_data: AnyBytes,
     network: EthereumNetworkInfo,
     address_bytes: AnyBytes,
     maximum_fee: str,
     fee_items: Iterable[StrPropertyType],
     sender_bytes: AnyBytes,
 ) -> tuple[ConfirmDataFn, Coroutine[Any, Any, None]] | None:
 
+    log.debug("SS DEBUG", "inside yielding get_approver")
+    log.debug("SS DEBUG", "data_length=%d initial_data_len=%d", msg.data_length, len(initial_data))
+    log.debug("SS DEBUG", "to=%s chain_id=%d", msg.to, network.chain_id)
+    log.debug("SS DEBUG", "sender_bytes=%s", sender_bytes)
+
     from .clear_signing import SC_FUNC_SIG_BYTES
     from .helpers import get_progress_indicator
 
-    if msg.data_length > len(msg.data_initial_chunk):
+    if msg.data_length > len(initial_data):
+        log.debug("SS DEBUG", "get_approver: data exceeds buffer, returning None (data_length=%d > initial_data=%d)", msg.data_length, len(initial_data))
         return None
 
-    data_reader = BufferReader(msg.data_initial_chunk)
+    data_reader = BufferReader(initial_data)
     if data_reader.remaining_count() < SC_FUNC_SIG_BYTES:
+        log.debug("SS DEBUG", "get_approver: not enough data for func sig, remaining=%d", data_reader.remaining_count())
         return None
 
     is_known_vault, vault_str, asset_token, vault_token = lookup_vault(
         network, address_bytes
     )
+    log.debug("SS DEBUG", "lookup_vault: is_known=%s vault_str=%s", is_known_vault, vault_str)
+    log.debug("SS DEBUG", "lookup_vault: asset_token=%s vault_token=%s", asset_token.symbol if asset_token else None, vault_token.symbol if vault_token else None)
 
     handler = None
     func_sig = data_reader.read_memoryview(SC_FUNC_SIG_BYTES)
+    log.debug("SS DEBUG", "func_sig=%s", func_sig)
+    log.debug("SS DEBUG", "func_sig matches DEPOSIT=%s WITHDRAW=%s REDEEM=%s CLAIM=%s",
+        func_sig == FUNC_SIG_DEPOSIT,
+        func_sig == FUNC_SIG_WITHDRAW,
+        func_sig == FUNC_SIG_REDEEM,
+        func_sig == FUNC_SIG_CLAIM,
+    )
     if func_sig in (FUNC_SIG_DEPOSIT, FUNC_SIG_WITHDRAW, FUNC_SIG_REDEEM):
         token = vault_token if func_sig == FUNC_SIG_REDEEM else asset_token
         handler = _prepare_vault_tx(
@@ -76,10 +98,25 @@ def get_approver(
             token=token,
             func_sig=func_sig,
         )
+    elif func_sig == FUNC_SIG_CLAIM:
+        log.debug("SS DEBUG", "get_approver: routing to _prepare_claim_rewards")
+        handler = _prepare_claim_rewards(
+            data_reader=data_reader,
+            msg=msg,
+            network=network,
+            maximum_fee=maximum_fee,
+            fee_items=fee_items,
+            sender_bytes=sender_bytes,
+            is_known_vault=is_known_vault,
+        )
+    else:
+        log.debug("SS DEBUG", "get_approver: func_sig not recognized, handler=None -> blind signing")
 
+    log.debug("SS DEBUG", "get_approver: handler=%s", handler)
     if handler is not None:
         progress_indicator = get_progress_indicator(msg.data_length)
         return progress_indicator, handler
+    log.debug("SS DEBUG", "get_approver: returning None -> will fall through to blind/clear signing")
     return None
 
 
@@ -119,7 +156,7 @@ def _prepare_vault_tx(
         ):
             raise ValueError
     except (ValueError, EOFError, InvalidFunctionCall):
-        raise DataError("Invalid data for ERC-4626 vault transaction")
+        raise DataError(f"Invalid data for ERC-4626 vault transaction. Remaining data count: {data_reader.remaining_count()}, amount: {amount}, eth_Value: {int.from_bytes(msg.value, 'big')}")
 
     if not _is_vault_tx_safe(is_known_vault, sender_bytes, receiver_bytes, owner_bytes):
         return None
@@ -135,22 +172,126 @@ def _prepare_vault_tx(
     )
 
 
+def _prepare_claim_rewards(
+    data_reader: BufferReader,
+    msg: MsgInSignTx,
+    network: EthereumNetworkInfo,
+    maximum_fee: str,
+    fee_items: Iterable[StrPropertyType],
+    sender_bytes: AnyBytes,
+    is_known_vault: bool,
+) -> "Coroutine[Any, Any, None] | None":
+    from .clear_signing import InvalidFunctionCall, parse_address
+    from .layout import require_confirm_claim_rewards
+    from .yielding_vaults import get_token_label
+
+    log.debug("SS DEBUG", "_prepare_claim_rewards: entered, is_known_vault=%s", is_known_vault)
+    log.debug("SS DEBUG", "_prepare_claim_rewards: sender_bytes=%s", sender_bytes)
+
+    # claim(address[] users, address[] tokens, uint256[] amounts, bytes32[][] proofs)
+    # All 4 params are dynamic; first 128 bytes are their ABI offsets.
+    try:
+        data = data_reader.read_memoryview(data_reader.remaining_count())
+        log.debug("SS DEBUG", "_prepare_claim_rewards: data len=%d", len(data))
+
+        if len(data) < 128:
+            log.debug("SS DEBUG", "_prepare_claim_rewards: data too short (<128), raising InvalidFunctionCall")
+            raise InvalidFunctionCall
+
+        users_param_offset = int.from_bytes(data[0:32], "big")
+        tokens_param_offset = int.from_bytes(data[32:64], "big")
+        amounts_param_offset = int.from_bytes(data[64:96], "big")
+        proofs_param_offset = int.from_bytes(data[96:128], "big")
+        log.debug("SS DEBUG", "offsets: users=%d tokens=%d amounts=%d proofs=%d", users_param_offset, tokens_param_offset, amounts_param_offset, proofs_param_offset)
+
+        if proofs_param_offset + 32 > len(data):
+            log.debug("SS DEBUG", "_prepare_claim_rewards: proofs_param_offset=%d + 32 > data len=%d, raising InvalidFunctionCall", proofs_param_offset, len(data))
+            raise InvalidFunctionCall
+
+        users_array_length = int.from_bytes(data[users_param_offset : users_param_offset + 32], "big")
+        tokens_array_length = int.from_bytes(data[tokens_param_offset : tokens_param_offset + 32], "big")
+        amounts_array_length = int.from_bytes(data[amounts_param_offset : amounts_param_offset + 32], "big")
+        proofs_array_length = int.from_bytes(data[proofs_param_offset : proofs_param_offset + 32], "big")
+        log.debug("SS DEBUG", "array lengths: users=%d tokens=%d amounts=%d proofs=%d", users_array_length, tokens_array_length, amounts_array_length, proofs_array_length)
+
+        if (
+            users_array_length != tokens_array_length
+            or tokens_array_length != amounts_array_length
+            or amounts_array_length != proofs_array_length
+        ):
+            log.debug("SS DEBUG", "_prepare_claim_rewards: array length mismatch! users=%d tokens=%d amounts=%d proofs=%d", users_array_length, tokens_array_length, amounts_array_length, proofs_array_length)
+            raise ValueError
+
+        user_address = parse_address(data[users_param_offset + 32 : users_param_offset + 64])
+        log.debug("SS DEBUG", "user_address[0]=%s type=%s", user_address, type(user_address))
+        if not isinstance(user_address, bytes):
+            log.debug("SS DEBUG", "_prepare_claim_rewards: user_address is not bytes, raising InvalidFunctionCall")
+            raise InvalidFunctionCall
+
+        # Check if all users are the same. We validate if it's the sender in _is_vault_tx_safe()
+        # If either of these conditions are unmet, we revert to blind signing (return None).
+        for i in range(1, users_array_length):
+            addr_start = users_param_offset + 32 + i * 32
+            other = parse_address(data[addr_start : addr_start + 32])
+            log.debug("SS DEBUG", "users[%d]=%s == users[0]=%s -> %s", i, other, user_address, other == user_address)
+            if other != user_address:
+                log.debug("SS DEBUG", "_prepare_claim_rewards: user[%d] != user[0], returning None (blind sign)", i)
+                return None
+
+        token_labels: list[str] = []
+        for i in range(tokens_array_length):
+            addr_start = tokens_param_offset + 32 + i * 32
+            addr = parse_address(data[addr_start : addr_start + 32])
+            if not isinstance(addr, bytes):
+                log.debug("SS DEBUG", "_prepare_claim_rewards: token[%d] addr not bytes, raising InvalidFunctionCall", i)
+                raise InvalidFunctionCall
+            label = get_token_label(addr, network)
+            log.debug("SS DEBUG", "token[%d] addr=%s label=%s", i, addr, label)
+            token_labels.append(label)
+
+    except (ValueError, EOFError, InvalidFunctionCall):
+        raise DataError("Invalid data for claim rewards transaction")
+
+    log.debug("SS DEBUG", "_prepare_claim_rewards: token_labels=%s", token_labels)
+    log.debug("SS DEBUG", "_prepare_claim_rewards: calling _is_vault_tx_safe sender=%s user_address=%s", sender_bytes, user_address)
+
+    if not _is_vault_tx_safe(is_known_vault, sender_bytes, user_address):
+        log.debug("SS DEBUG", "_prepare_claim_rewards: _is_vault_tx_safe returned False, returning None")
+        return None
+
+    log.debug("SS DEBUG", "_prepare_claim_rewards: all checks passed, returning confirm coroutine")
+    return require_confirm_claim_rewards(
+        address_n=msg.address_n,
+        maximum_fee=maximum_fee,
+        fee_info_items=fee_items,
+        token_labels=token_labels,
+    )
+
 def _is_vault_tx_safe(
     is_known_vault: bool,
     sender_bytes: AnyBytes,
     receiver_bytes: AnyBytes,
     owner_bytes: AnyBytes | None = None,
 ) -> bool:
 
+    log.debug("SS DEBUG", "_is_vault_tx_safe: is_known_vault=%s", is_known_vault)
+    log.debug("SS DEBUG", "_is_vault_tx_safe: sender_bytes=%s", sender_bytes)
+    log.debug("SS DEBUG", "_is_vault_tx_safe: receiver_bytes=%s", receiver_bytes)
+    log.debug("SS DEBUG", "_is_vault_tx_safe: sender==receiver -> %s", receiver_bytes == sender_bytes)
+
     is_calldata_safe = receiver_bytes == sender_bytes
     if owner_bytes is not None:
         # Withdraw/redeem transaction
+        log.debug("SS DEBUG", "_is_vault_tx_safe: owner_bytes=%s sender==owner -> %s", owner_bytes, owner_bytes == sender_bytes)
         is_calldata_safe = is_calldata_safe and owner_bytes == sender_bytes
 
+    log.debug("SS DEBUG", "_is_vault_tx_safe: is_calldata_safe=%s", is_calldata_safe)
     if is_calldata_safe:
         return True
     else:
         # Hard fail for known (Trezor) vaults, blind sign for unknown vaults
         if is_known_vault:
+            log.debug("SS DEBUG", "_is_vault_tx_safe: known vault mismatch -> raising DataError")
             raise DataError("Vault tx: Signer receiver mismatch")
+        log.debug("SS DEBUG", "_is_vault_tx_safe: unknown vault mismatch -> returning False (blind sign)")
         return False

core/src/apps/ethereum/yielding.py

@@ -12,7 +12,7 @@
     # Test vault: https://etherscan.io/address/0xa511d618cD0F9d7cAD791009d7c5E3b19c9568da
     b"\xa5\x11\xd6\x18\xcd\x0f\x9d\x7c\xad\x79\x10\x09\xd7\xc5\xe3\xb1\x9c\x95\x68\xda",  # vault contract address
     1,  # chain id (Ethereum)
-    "Test Steakhouse USDC Prime Vault",  # owner/protocol name
+    "Test Steakhouse USDC Prime Vault",  # Vault Name
     # Asset Token
     EthereumTokenInfo(
         symbol="USDC",
@@ -31,6 +31,16 @@
     ),
 )
 
+def get_token_label(token_addr: AnyBytes, network: EthereumNetworkInfo) -> str:
+    # Only known token for now. We can use clear signing here to request token definitions from Connect, once it is done.
+    # https://etherscan.io/token/0x58d97b57bb95320f9a05dc918aef65434969c2b2
+    _MORPHO_ADDR = b"\x58\xd9\x7b\x57\xbb\x95\x32\x0f\x9a\x05\xdc\x91\x8a\xef\x65\x43\x49\x69\xc2\xb2"
+
+    if token_addr == _MORPHO_ADDR and network.chain_id == 1:
+        return "MORPHO"
+    else:
+        return "UNKNOWN"
+
 
 def lookup_vault(
     network: EthereumNetworkInfo, vault_addr: AnyBytes

core/src/apps/ethereum/yielding_vaults.py

@@ -1370,7 +1370,7 @@ async def confirm_ethereum_vault_tx(
         await confirm_value(
             title=title,
             value=vault_str,
-            description="",
+            description=verb,
             br_name=br_name + "/vault",
             br_code=br_code,
             verb=TR.buttons__continue,
@@ -1398,6 +1398,55 @@ async def confirm_ethereum_vault_tx(
             br_code=br_code,
         )
 
+    async def confirm_ethereum_vault_claim(
+            title: str,
+            intro_question: str,
+            account: str | None,
+            account_path: str | None,
+            maximum_fee: str,
+            info_items: Iterable[StrPropertyType],
+            token_list: str,
+            br_name: str,
+    ) -> None:
+
+        account_properties: list[StrPropertyType] = []
+        if account:
+            account_properties.append((TR.words__account, account, None))
+        if account_path:
+            account_properties.append(
+                (TR.address_details__derivation_path, account_path, None)
+            )
+
+        await confirm_value(
+            title=title,
+            value=intro_question,
+            description="",
+            br_name=br_name + "/intro",
+            verb=TR.buttons__continue,
+            is_data=False,
+            info_items=account_properties if account_properties else None,
+            info_title=TR.address_details__account_info,
+        )
+
+        await confirm_properties(
+            br_name=br_name + "/tokens",
+            title=title,
+            props=[
+                (TR.ethereum__reward_tokens, token_list, False)
+            ],
+        )
+
+        await _confirm_summary(
+            amount=None,
+            amount_label=None,
+            fee=maximum_fee,
+            fee_label=TR.send__maximum_fee,
+            title=title,
+            extra_items=info_items,
+            extra_title=TR.confirm_total__title_fee,
+            br_name=br_name + "/summary",
+        )
+
     def confirm_solana_unknown_token_warning() -> Awaitable[None]:
         return show_danger(
             "unknown_token_warning", content=TR.solana__unknown_token_address