test: regression coverage for 7.15.0 firmware fixes

EIP-1559 (fix/eip1559):
- test_eip1559_base_chain_id: Base mainnet chain_id=8453 (overflows uint8_t)
- test_eip1559_arbitrum_chain_id: Arbitrum One chain_id=42161
- test_eip1559_avalanche_chain_id: Avalanche C-Chain chain_id=43114

Token chain-id (fix/token-chain-id):
- test_erc20_transfer_arbitrum: ERC-20 transfer on Arbitrum (chain_id=42161)
- test_erc20_transfer_base: ERC-20 transfer on Base (chain_id=8453)

EIP-712 security (fix/eip712-security):
- TestEIP712Security.test_eip712_normal_hash_signing_still_works
- TestEIP712Security.test_eip712_hash_signing_no_message_hash

Ripple memo (feat/ripple-memo):
- test_ripple_sign_no_memo_backward_compat: omitting memo must not change serialized bytes

THORChain any-denom (feat/thorchain-any-denom):
- test_thorchain_rune_denom_backward_compat: rune path unchanged after firmware fix
- test_thorchain_msgsend_direct_with_denom: direct proto call with denom (skips if pb2 not updated)

Solana token decimals (fix/solana-token-decimals):
- test_solana_token_transfer_checked_decimals_6: TokenTransferChecked with decimals=6
- test_solana_token_transfer_checked_decimals_9: TokenTransferChecked with decimals=9

TRON blind-sign (fix/tron-blind-sign):
- test_tron_blind_sign_still_completes_after_ux_fix

TON blind-sign (fix/ton-blind-sign):
- test_ton_blind_sign_still_completes_after_ux_fix

Author: BitHighlander

tests/test_msg_ethereum_signtx.py

@@ -532,6 +532,91 @@ def test_ethereum_signtx_nodata(self):
             "6e33c4230b1ecf96a8dbb514b4aec0a6d6ba53f8991c8143f77812aa6daa993f",
         )
 
+    # ------------------------------------------------------------------ #
+    # Regression: fix/eip1559 — chain_id >= 256 RLP encoding bug         #
+    # Before the fix, large chain IDs were stored as uint8_t which        #
+    # silently truncated to the low byte, producing a wrong signer.       #
+    # ------------------------------------------------------------------ #
+
+    def test_eip1559_base_chain_id(self):
+        """Regression for fix/eip1559 — EIP-1559 signing on Base (chain_id=8453).
+
+        chain_id=8453 overflows uint8_t (max 255).  Before the fix the device
+        signed with chain_id & 0xFF = 5 instead of 8453, recovering the wrong
+        signer address.  This test verifies the signature is produced without
+        error and that sig_v is 0 or 1 (EIP-1559 parity, not the legacy value).
+        """
+        self.requires_fullFeature()
+        self.requires_firmware("7.15.0")
+        self.setup_mnemonic_allallall()
+
+        sig_v, sig_r, sig_s = self.client.ethereum_sign_tx(
+            n=[0x80000000 | 44, 0x80000000 | 60, 0x80000000, 0, 0],
+            nonce=0,
+            max_fee_per_gas=100000000000,        # 100 gwei
+            max_priority_fee_per_gas=1000000000, # 1 gwei
+            gas_limit=21000,
+            to=binascii.unhexlify("1d1c328764a41bda0492b66baa30c4a339ff85ef"),
+            value=1000000000000000,  # 0.001 ETH
+            chain_id=8453,           # Base mainnet
+        )
+
+        # EIP-1559 parity must be 0 or 1 (never 0x21 etc. from wrong chain_id)
+        self.assertIn(sig_v, (0, 1), "EIP-1559 sig_v must be 0 or 1 for Base chain_id=8453")
+        self.assertEqual(len(sig_r), 32)
+        self.assertEqual(len(sig_s), 32)
+
+    def test_eip1559_arbitrum_chain_id(self):
+        """Regression for fix/eip1559 — EIP-1559 signing on Arbitrum One (chain_id=42161).
+
+        chain_id=42161 (0xA4B1) was affected by the same uint8_t truncation.
+        Verifies the device signs successfully and max_priority_fee_per_gas
+        is honoured (non-zero tip distinguishes this from a legacy tx).
+        """
+        self.requires_fullFeature()
+        self.requires_firmware("7.15.0")
+        self.setup_mnemonic_allallall()
+
+        sig_v, sig_r, sig_s = self.client.ethereum_sign_tx(
+            n=[0x80000000 | 44, 0x80000000 | 60, 0x80000000, 0, 0],
+            nonce=1,
+            max_fee_per_gas=200000000000,        # 200 gwei
+            max_priority_fee_per_gas=2000000000, # 2 gwei priority tip
+            gas_limit=21000,
+            to=binascii.unhexlify("1d1c328764a41bda0492b66baa30c4a339ff85ef"),
+            value=5000000000000000,  # 0.005 ETH
+            chain_id=42161,          # Arbitrum One
+        )
+
+        self.assertIn(sig_v, (0, 1), "EIP-1559 sig_v must be 0 or 1 for Arbitrum chain_id=42161")
+        self.assertEqual(len(sig_r), 32)
+        self.assertEqual(len(sig_s), 32)
+
+    def test_eip1559_avalanche_chain_id(self):
+        """Regression for fix/eip1559 — EIP-1559 signing on Avalanche C-Chain (chain_id=43114).
+
+        chain_id=43114 rounds to 0x2A when truncated to uint8_t.  Verify
+        signing works and parity is valid EIP-1559 (0 or 1).
+        """
+        self.requires_fullFeature()
+        self.requires_firmware("7.15.0")
+        self.setup_mnemonic_allallall()
+
+        sig_v, sig_r, sig_s = self.client.ethereum_sign_tx(
+            n=[0x80000000 | 44, 0x80000000 | 60, 0x80000000, 0, 0],
+            nonce=2,
+            max_fee_per_gas=30000000000,         # 30 gwei
+            max_priority_fee_per_gas=500000000,  # 0.5 gwei
+            gas_limit=21000,
+            to=binascii.unhexlify("1d1c328764a41bda0492b66baa30c4a339ff85ef"),
+            value=100000000000000000,  # 0.1 AVAX
+            chain_id=43114,            # Avalanche C-Chain
+        )
+
+        self.assertIn(sig_v, (0, 1), "EIP-1559 sig_v must be 0 or 1 for Avalanche chain_id=43114")
+        self.assertEqual(len(sig_r), 32)
+        self.assertEqual(len(sig_s), 32)
+
 
 if __name__ == "__main__":
     unittest.main()

tests/test_msg_ripple_sign_tx.py

@@ -151,6 +151,48 @@ def test_sign_with_thorchain_memo(self):
             "plain send must not contain Memos array (0xF9 marker)"
         )
 
+    # ------------------------------------------------------------------ #
+    # Regression: feat/ripple-memo — memo field, backward compat          #
+    # Firmware 7.14.2 added optional memo (field 7) to RippleSignTx.      #
+    # A tx without memo must still produce the same serialized bytes as   #
+    # before — adding an optional field must not change existing encodings.#
+    # ------------------------------------------------------------------ #
+
+    def test_ripple_sign_no_memo_backward_compat(self):
+        """Regression for feat/ripple-memo — signing without memo must be byte-identical to pre-7.14.2.
+
+        The Memos field is optional.  Omitting it must not change the
+        serialized transaction encoding (no trailing 0xF9 marker).
+        The expected serialized_tx is pinned from the original test_sign test.
+        """
+        self.requires_fullFeature()
+        self.requires_firmware("7.14.2")
+        self.setup_mnemonic_allallall()
+
+        msg = messages.RippleSignTx(
+            address_n=parse_path("m/44'/144'/0'/0/0"),
+            payment=messages.RipplePayment(
+                amount=100000000,
+                destination="rBKz5MC2iXdoS3XgnNSYmF69K1Yo4NS3Ws",
+            ),
+            flags=0x80000000,
+            fee=100000,
+            sequence=25,
+            # memo field intentionally absent
+        )
+        resp = self.client.call(msg)
+
+        # Must match the serialized bytes from the pre-memo firmware exactly
+        self.assertEqual(
+            binascii.hexlify(resp.serialized_tx),
+            "12000022800000002400000019614000000005f5e1006840000000000186a0732102131facd1eab748d6cddc492f54b04e8c35658894f4add2232ebc5afe7521dbe474473045022100e243ef623675eeeb95965c35c3e06d63a9fc68bb37e17dc87af9c0af83ec057e02206ca8aa5eaab8396397aef6d38d25710441faf7c79d292ee1d627df15ad9346c081148fb40e1ffa5d557ce9851a535af94965e0dd098883147148ebebf7304ccdf1676fefcf9734cf1e780826",
+        )
+        # No Memos STArray marker (0xF9) should appear in the output
+        self.assertFalse(
+            b'\xf9' in resp.serialized_tx,
+            "Plain send without memo must not contain XRPL Memos array (0xF9 marker)",
+        )
+
     def test_ripple_sign_invalid_fee(self):
         self.requires_fullFeature()
         self.requires_firmware("6.4.0")

tests/test_msg_signtx_ethereum_erc20.py

@@ -86,6 +86,77 @@ def test_approve_all(self):
         self.assertEqual(binascii.hexlify(sig_r), '3671acb6aed5241948de56635ef64554d5e834355e99d806c4ae30bf463eae57')
         self.assertEqual(binascii.hexlify(sig_s), '2b0aa2fdfabefb4ae687f3418b13cddf1111e62338bc8fd3ca4e0196352bb6f8')
 
+    # ------------------------------------------------------------------ #
+    # Regression: fix/token-chain-id — uint8_t overflow for chain_id>255 #
+    # ERC-20 token lookup used a uint8_t for chain_id, silently wrapping  #
+    # for Arbitrum (42161), Base (8453), and Avalanche (43114).           #
+    # ------------------------------------------------------------------ #
+
+    def test_erc20_transfer_arbitrum(self):
+        """Regression for fix/token-chain-id — ERC-20 transfer on Arbitrum One.
+
+        chain_id=42161 previously overflowed uint8_t in the token lookup table,
+        causing the display to show the wrong (or no) token name.  This test
+        verifies signing completes without error on Arbitrum.
+        """
+        self.requires_fullFeature()
+        self.requires_firmware("7.15.0")
+        self.setup_mnemonic_allallall()
+
+        # USDT on Arbitrum One (0xfd086bc7cd5c481dcc9c85ebe478a1c0b69fcbb9)
+        # transfer(address,uint256): 0xa9059cbb + padded recipient + amount
+        recipient = '0000000000000000000000001d1c328764a41bda0492b66baa30c4a339ff85ef'
+        amount    = '000000000000000000000000000000000000000000000000000000003b9aca00'  # 1000 USDT (6 dec)
+        transfer_data = binascii.unhexlify('a9059cbb' + recipient + amount)
+
+        sig_v, sig_r, sig_s = self.client.ethereum_sign_tx(
+            n=[0x80000000 | 44, 0x80000000 | 60, 0x80000000, 0, 0],
+            nonce=0,
+            gas_price=100000000,  # 0.1 gwei (Arbitrum is cheap)
+            gas_limit=65000,
+            value=0,
+            to=binascii.unhexlify('fd086bc7cd5c481dcc9c85ebe478a1c0b69fcbb9'),
+            chain_id=42161,       # Arbitrum One
+            data=transfer_data,
+        )
+
+        # EIP-155 replay protection: v = 2*chain_id + 35 or 36 = 84357 or 84358
+        self.assertIn(sig_v, (84357, 84358),
+                      "Expected EIP-155 v for Arbitrum chain_id=42161, got %d" % sig_v)
+        self.assertEqual(len(sig_r), 32)
+        self.assertEqual(len(sig_s), 32)
+
+    def test_erc20_transfer_base(self):
+        """Regression for fix/token-chain-id — ERC-20 transfer on Base (chain_id=8453).
+
+        chain_id=8453 also overflowed the uint8_t token lookup.
+        """
+        self.requires_fullFeature()
+        self.requires_firmware("7.15.0")
+        self.setup_mnemonic_allallall()
+
+        # USDC on Base (0x833589fcd6edb6e08f4c7c32d4f71b54bda02913)
+        recipient = '0000000000000000000000001d1c328764a41bda0492b66baa30c4a339ff85ef'
+        amount    = '0000000000000000000000000000000000000000000000000000000000989680'  # 10 USDC
+        transfer_data = binascii.unhexlify('a9059cbb' + recipient + amount)
+
+        sig_v, sig_r, sig_s = self.client.ethereum_sign_tx(
+            n=[0x80000000 | 44, 0x80000000 | 60, 0x80000000, 0, 0],
+            nonce=0,
+            gas_price=50000000,   # 0.05 gwei
+            gas_limit=65000,
+            value=0,
+            to=binascii.unhexlify('833589fcd6edb6e08f4c7c32d4f71b54bda02913'),
+            chain_id=8453,        # Base
+            data=transfer_data,
+        )
+
+        # EIP-155: v = 2*8453 + 35 or 36 = 16941 or 16942
+        self.assertIn(sig_v, (16941, 16942),
+                      "Expected EIP-155 v for Base chain_id=8453, got %d" % sig_v)
+        self.assertEqual(len(sig_r), 32)
+        self.assertEqual(len(sig_s), 32)
+
 
 if __name__ == '__main__':
     unittest.main()

tests/test_msg_solana_signtx.py

@@ -575,6 +575,87 @@ def test_solana_sign_token_transfer_with_metadata(self):
         self.assertEqual(len(resp.signature), 64)
         self.assertFalse(all(b == 0 for b in resp.signature))
 
+    # ------------------------------------------------------------------ #
+    # Regression: fix/solana-token-decimals                               #
+    # The instruction-level decimals field in TokenTransferChecked was    #
+    # ignored; the host-supplied token_info.decimals were used instead.   #
+    # After the fix the instruction decimals override host metadata.      #
+    # ------------------------------------------------------------------ #
+
+    def test_solana_token_transfer_checked_decimals_6(self):
+        """Regression for fix/solana-token-decimals — TokenTransferChecked with decimals=6.
+
+        SPL Token TransferChecked (opcode=12) embeds explicit decimals in the
+        instruction.  Before the fix the firmware used host metadata decimals
+        instead of the instruction field.  This test verifies the instruction
+        signs correctly with decimals=6 passed inside the instruction data.
+        """
+        self.requires_fullFeature()
+        self.requires_firmware("7.15.0")
+        self.setup_mnemonic_allallall()
+
+        from_pubkey = self._get_from_pubkey()
+        to_account  = b'\x33' * 32  # destination token account
+        mint_pubkey = b'\x44' * 32  # token mint
+
+        # SPL Token TransferChecked: opcode=12 (u8) + amount (LE u64) + decimals (u8)
+        # Format: [12] [amount:8 LE] [decimals:1]
+        amount   = 5000000  # 5.0 USDC (6 decimals)
+        decimals = 6
+        instr_data = bytes([12]) + struct.pack('<Q', amount) + bytes([decimals])
+
+        # TransferChecked needs: source, mint, destination, owner (in addition to from_pubkey)
+        # Build tx with 4 extra accounts: source_ata, mint, dest_ata, owner(=from_pubkey)
+        source_ata = b'\x55' * 32
+
+        raw_tx = self._build_tx(
+            from_pubkey,
+            [source_ata, mint_pubkey, to_account],
+            self.TOKEN_PROGRAM,
+            instr_data,
+        )
+
+        resp = self.client.call(messages.SolanaSignTx(
+            address_n=parse_path("m/44'/501'/0'/0'"),
+            raw_tx=raw_tx,
+        ))
+
+        self.assertEqual(len(resp.signature), 64)
+        self.assertFalse(all(b == 0 for b in resp.signature))
+
+    def test_solana_token_transfer_checked_decimals_9(self):
+        """Regression for fix/solana-token-decimals — TokenTransferChecked with decimals=9.
+
+        Verifies a second decimal precision (SOL-like 9-decimal token) signs
+        correctly — ensures the fix handles decimals != 6 too.
+        """
+        self.requires_fullFeature()
+        self.requires_firmware("7.15.0")
+        self.setup_mnemonic_allallall()
+
+        from_pubkey = self._get_from_pubkey()
+        to_account  = b'\x33' * 32
+        mint_pubkey = b'\x66' * 32
+        source_ata  = b'\x77' * 32
+
+        # TransferChecked with 9 decimals, amount 1_000_000_000 (= 1.0 token)
+        instr_data = bytes([12]) + struct.pack('<Q', 1000000000) + bytes([9])
+
+        raw_tx = self._build_tx(
+            from_pubkey,
+            [source_ata, mint_pubkey, to_account],
+            self.TOKEN_PROGRAM,
+            instr_data,
+        )
+
+        resp = self.client.call(messages.SolanaSignTx(
+            address_n=parse_path("m/44'/501'/0'/0'"),
+            raw_tx=raw_tx,
+        ))
+
+        self.assertEqual(len(resp.signature), 64)
+        self.assertFalse(all(b == 0 for b in resp.signature))
+
     # ================================================================
     # Path edge-case tests
     # ================================================================