eth/erc20_params: group tokens also by unit len to save more bytes

This way we don't have to repeat storing the length of the unit
string (if using `&str`) and also not repeat the 0-terminator (if
using C-style strings) per token, shaving off another ~1 byte per
token in the firmware binary (currently ~ -1600 bytes).

Author: benma

src/rust/erc20_params/build.rs

@@ -53,10 +53,10 @@ fn main() {
     }
 
     // Group tokens by decimals
-    let mut grouped_tokens: HashMap<u8, Vec<&Token>> = HashMap::new();
+    let mut grouped_tokens: HashMap<(u8, u8), Vec<&Token>> = HashMap::new();
     for token in &tokens {
         grouped_tokens
-            .entry(token.decimals)
+            .entry((token.decimals, token.unit.len().try_into().unwrap()))
             .or_default()
             .push(token);
     }
@@ -69,12 +69,17 @@ fn main() {
         .open(out_filename)
         .unwrap();
 
-    for (decimals, tokens) in &grouped_tokens {
-        writeln!(output_file, "const PARAMS_{}: &[P] = &[", decimals).unwrap();
+    for ((decimals, unit_len), tokens) in &grouped_tokens {
+        writeln!(
+            output_file,
+            "const PARAMS_D{}_U{}: &[P] = &[",
+            decimals, unit_len
+        )
+        .unwrap();
         for token in tokens {
             writeln!(
                 output_file,
-                "    P {{ unit: b\"{}\\0\".as_ptr(), contract_address: *b\"{}\" }},",
+                "    P {{ unit: b\"{}\".as_ptr(), contract_address: *b\"{}\" }},",
                 token.unit,
                 token
                     .contract_address
@@ -87,14 +92,15 @@ fn main() {
         writeln!(output_file, "];").unwrap();
     }
 
-    let mut decimals_vec: Vec<u8> = grouped_tokens.keys().cloned().collect();
-    decimals_vec.sort();
     writeln!(
         output_file,
-        "const ALL: &[(u8, &[P])] = &[{}];",
-        decimals_vec
-            .iter()
-            .map(|decimal| format!("({}, PARAMS_{})", decimal, decimal))
+        "const ALL: &[(u8, u8, &[P])] = &[{}];",
+        grouped_tokens
+            .keys()
+            .map(|(decimal, unit_len)| format!(
+                "({}, {}, PARAMS_D{}_U{})",
+                decimal, unit_len, decimal, unit_len
+            ))
             .collect::<Vec<String>>()
             .join(", ")
     )

src/rust/erc20_params/src/lib.rs

@@ -31,11 +31,14 @@ pub struct Params {
 }
 
 impl Params {
-    fn from_p(p: &P, decimals: u8) -> Self {
+    fn from_p(p: &P, decimals: u8, unit_len: u8) -> Self {
         Params {
-            unit: (unsafe { core::ffi::CStr::from_ptr(p.unit as *const i8) })
-                .to_str()
-                .unwrap(),
+            unit: unsafe {
+                core::str::from_utf8_unchecked(core::slice::from_raw_parts(
+                    p.unit,
+                    unit_len as usize,
+                ))
+            },
             contract_address: p.contract_address,
             decimals,
         }
@@ -52,11 +55,11 @@ pub fn get(chain_id: u64, contract_address: [u8; 20]) -> Option<Params> {
     if chain_id != 1 {
         return None;
     }
-    for &(decimals, params) in ALL.iter() {
+    for &(decimals, unit_len, params) in ALL.iter() {
         let result = params
             .iter()
             .find(|p| p.contract_address == contract_address)
-            .map(|p| Params::from_p(p, decimals));
+            .map(|p| Params::from_p(p, decimals, unit_len));
         if result.is_some() {
             return result;
         }