fix(tokens): key deduplication on (chain_id, address)

token_policy.select() deduplicated on address alone, but an Ethereum token's
identity is (chain_id, address). The vetted source carries the same address
on several chains -- 0x0000..0000 is listed as BURNER under EXP (2), OP (10)
and MATIC (137) -- so every chain after the first was silently dropped from
the generated firmware table. Verified: chains 10 and 137 were absent before
this change and present after, while the genuine same-chain duplicate (CARD
twice on chain 1) is still collapsed.

uniswap_tokens passes a constant 1 because its list is mainnet-only, which
serialize_c already hardcodes.

Author: pastaghost

keepkeylib/eth/ethereum_tokens.py

@@ -55,7 +55,8 @@ def serialize_c(self, outf):
             self.tokens,
             token_policy.BUDGET_ETHEREUM_LISTS,
             symbol_of=lambda t: t.token.get('symbol', ''),
-            address_of=lambda t: t.token['address'].lower())
+            address_of=lambda t: t.token['address'].lower(),
+            chain_of=lambda t: t.network['chain_id'])
         print('ethereum_tokens: %d of %d kept (budget %d)'
               % (len(chosen), len(self.tokens),
                  token_policy.BUDGET_ETHEREUM_LISTS), file=sys.stderr)

keepkeylib/eth/token_policy.py

@@ -87,14 +87,27 @@
                     + STABLECOINS + MAJORS)
 
 
-def select(records, budget, symbol_of, address_of):
+def select(records, budget, symbol_of, address_of, chain_of=None):
     """Return `records` trimmed to `budget`, priority symbols first.
 
     `records` is any iterable; `symbol_of`/`address_of` pull the two fields.
     Priority symbols with more than one address in `records` are DROPPED from
     the priority pass -- see rule 3 -- though they may still be picked up by
     the deterministic fill, where they carry no special standing.
+
+    `chain_of` supplies the chain id. A token's identity is (chain_id,
+    address), NOT address alone: the vetted source carries the same address on
+    several chains -- 0x0000..0000 is listed as BURNER under EXP (2), OP (10)
+    and MATIC (137) -- and deduplicating on address alone silently dropped
+    every chain after the first from the generated firmware table. Left as
+    None the key falls back to address alone, which is only correct for a
+    single-chain source.
     """
+    if chain_of is None:
+        chain_of = lambda r: None
+
+    def key_of(r):
+        return (chain_of(r), address_of(r))
     records = list(records)
     by_symbol = {}
     for r in records:
@@ -108,15 +121,15 @@ def select(records, budget, symbol_of, address_of):
             ambiguous.append(sym)
             continue
         for r in hits:
-            key = address_of(r)
+            key = key_of(r)
             if key not in seen:
                 seen.add(key)
                 chosen.append(r)
 
     for r in sorted(records, key=address_of):
         if len(chosen) >= budget:
             break
-        key = address_of(r)
+        key = key_of(r)
         if key not in seen:
             seen.add(key)
             chosen.append(r)

keepkeylib/eth/uniswap_tokens.py

@@ -38,7 +38,10 @@ def serialize_c(self):
             self.ustoks,
             token_policy.BUDGET_UNISWAP_LIST,
             symbol_of=lambda t: t.token.get('symbol', ''),
-            address_of=lambda t: t.token['contractAddress'].lower())
+            address_of=lambda t: t.token['contractAddress'].lower(),
+            # This list is mainnet-only (serialize_c hardcodes chain_id 1),
+            # so the chain component is constant rather than absent.
+            chain_of=lambda t: 1)
         print('uniswap_tokens: %d of %d kept (budget %d)'
               % (len(chosen), len(self.ustoks),
                  token_policy.BUDGET_UNISWAP_LIST), file=_sys.stderr)