Merge pull request #22 from alephium/token-metadata

Display the token amount and token symbol

Author: polarker

README.md

@@ -21,7 +21,8 @@ make run-speculos-<device>
 Run the tests:
 
 ```shell
-cd js && npm run speculos-test
+cd js/docker && docker compose up -d && cd ..
+npm install && MODEL=<device> npm run speculos-test
 ```
 
 ### Test with a Ledger Device

app/src/error_code.rs

@@ -16,6 +16,8 @@ pub enum ErrorCode {
     HDPathDecodingFailed = 0xE003,
     BlindSigningDisabled = 0xE004,
     DerivingPublicKeyFailed = 0xE005,
+    InvalidTokenSize = 0xE006,
+    InvalidMetadataVersion = 0xE007,
     InternalError = 0xEF00,
 }
 

app/src/handler.rs

@@ -6,7 +6,10 @@ use crate::{
     error_code::ErrorCode,
     public_key::derive_pub_key,
     sign_tx_context::{check_blind_signing, SignTxContext},
-    ui::{review_address, sign_hash_ui, tx_reviewer::TxReviewer},
+    ui::{
+        review_address, sign_hash_ui,
+        tx_reviewer::{TxReviewer, TOKEN_METADATA_SIZE},
+    },
 };
 
 #[repr(u8)]
@@ -120,25 +123,47 @@ pub fn handle_apdu(
     Ok(())
 }
 
+const MAX_TOKEN_SIZE: u8 = 5;
+
 fn handle_sign_tx(
     apdu_header: &ApduHeader,
     data: &[u8],
     sign_tx_context: &mut SignTxContext,
     tx_reviewer: &mut TxReviewer,
 ) -> Result<(), ErrorCode> {
     match apdu_header.p1 {
-        0 if data.len() < 23 => Err(ErrorCode::BadLen),
+        0 if data.len() < 21 => Err(ErrorCode::BadLen), // 20 bytes path + 1 byte token size
         0 => {
             sign_tx_context.init(data)?;
-            let tx_data = &data[20..];
+            let token_size = data[20];
+            if token_size > MAX_TOKEN_SIZE {
+                return Err(ErrorCode::InvalidTokenSize);
+            }
+            let tx_data_index: usize = 21 + TOKEN_METADATA_SIZE * (token_size as usize);
+            if data.len() < tx_data_index + 3 {
+                return Err(ErrorCode::BadLen);
+            }
+            let tx_data = &data[tx_data_index..];
             let is_tx_execute_script = tx_data[2] == 0x01;
             if is_tx_execute_script {
                 check_blind_signing()?;
             }
-            tx_reviewer.init(is_tx_execute_script);
+            let token_metadata = &data[21..tx_data_index];
+            check_token_metadata(token_size, token_metadata)?;
+            tx_reviewer.init(is_tx_execute_script, token_metadata)?;
             sign_tx_context.handle_data(apdu_header, tx_data, tx_reviewer)
         }
         1 => sign_tx_context.handle_data(apdu_header, data, tx_reviewer),
         _ => Err(ErrorCode::BadP1P2),
     }
 }
+
+fn check_token_metadata(token_size: u8, token_metadata: &[u8]) -> Result<(), ErrorCode> {
+    for i in 0..token_size {
+        let version_index = (i as usize) * TOKEN_METADATA_SIZE;
+        if token_metadata[version_index] != 0 {
+            return Err(ErrorCode::InvalidMetadataVersion);
+        }
+    }
+    Ok(())
+}

app/src/ledger_sdk_stub/multi_field_review.rs

@@ -171,7 +171,8 @@ impl<'a> Field<'a> {
     pub fn event_loop(&self, incoming_direction: ButtonEvent, is_first_field: bool) -> ButtonEvent {
         let mut buttons = ButtonsState::new();
         let chunk_max_lines = layout::MAX_LINES - 1;
-        let page_count = 1 + self.value.len() / (chunk_max_lines * MAX_CHAR_PER_LINE);
+        let max_size_per_page = chunk_max_lines * MAX_CHAR_PER_LINE;
+        let page_count = (self.value.len() + max_size_per_page - 1) / max_size_per_page;
 
         let mut cur_page = match incoming_direction {
             ButtonEvent::LeftButtonRelease => page_count - 1,

app/src/ledger_sdk_stub/swapping_buffer.rs

@@ -131,8 +131,8 @@ impl<'a, const RAM: usize, const FLASH: usize> SwappingBuffer<'a, RAM, FLASH> {
         }
     }
 
-    pub fn reset(&mut self) {
-        self.state = BufferState::default();
+    pub fn reset(&mut self, from_index: usize) {
+        self.state = BufferState::WritingToRam(from_index);
     }
 }
 

app/src/sign_tx_context.rs

@@ -48,7 +48,7 @@ impl SignTxContext {
         self.tx_decoder.reset();
         self.current_step = DecodeStep::Init;
         self.hasher.reset();
-        self.temp_data.reset();
+        self.temp_data.reset(0);
         self.device_address = Some(Address::from_path(&self.path)?);
         Ok(())
     }
@@ -80,7 +80,7 @@ impl SignTxContext {
                         self.device_address.as_ref().unwrap(),
                         &self.temp_data,
                     )?;
-                    self.temp_data.reset();
+                    self.temp_data.reset(0);
                     if self.tx_decoder.inner.is_complete() {
                         self.current_step = DecodeStep::Complete;
                         return Ok(());

app/src/ui/tx_reviewer.rs

@@ -20,20 +20,27 @@ use ledger_device_sdk::nbgl::{Field, TagValueList};
 use ledger_device_sdk::ui::bitmaps::{CHECKMARK, CROSS, EYE, WARNING};
 use utils::{
     base58::ALPHABET,
-    types::{AssetOutput, Byte32, LockupScript, TxInput, UnlockScript, UnsignedTx, I32, U256},
+    types::{
+        AssetOutput, Byte32, Hash, LockupScript, Token, TxInput, UnlockScript, UnsignedTx, I32,
+        U256,
+    },
 };
 
 #[link_section = ".nvm_data"]
 static mut DATA: NVMData<NVM<NVM_DATA_SIZE>> = NVMData::new(NVM::zeroed());
 
 const FIRST_OUTPUT_INDEX: u16 = 1;
+pub const TOKEN_METADATA_SIZE: usize = 46;
+const MAX_TOKEN_SYMBOL_LENGTH: usize = 12;
+type TokenSymbol = [u8; MAX_TOKEN_SYMBOL_LENGTH];
 
 pub struct TxReviewer {
     buffer: SwappingBuffer<'static, RAM_SIZE, NVM_DATA_SIZE>,
     has_external_inputs: bool,
     next_output_index: u16,
     tx_fee: Option<U256>,
     is_tx_execute_script: bool,
+    token_metadata_length: usize,
 }
 
 impl TxReviewer {
@@ -44,21 +51,29 @@ impl TxReviewer {
             next_output_index: FIRST_OUTPUT_INDEX, // display output from index 1, similar to BTC
             tx_fee: None,
             is_tx_execute_script: false,
+            token_metadata_length: 0,
         }
     }
 
     #[inline]
-    fn reset_buffer(&mut self) {
-        self.buffer.reset();
+    fn reset_buffer(&mut self, from_index: usize) {
+        self.buffer.reset(from_index);
     }
 
     #[inline]
-    pub fn init(&mut self, is_tx_execute_script: bool) {
-        self.reset_buffer();
+    pub fn init(
+        &mut self,
+        is_tx_execute_script: bool,
+        token_metadata: &[u8],
+    ) -> Result<(), ErrorCode> {
+        self.reset_buffer(0);
+        self.buffer.write(token_metadata)?;
         self.has_external_inputs = false;
         self.next_output_index = FIRST_OUTPUT_INDEX;
         self.tx_fee = None;
         self.is_tx_execute_script = is_tx_execute_script;
+        self.token_metadata_length = token_metadata.len();
+        Ok(())
     }
 
     fn write_alph_amount(&mut self, u256: &U256) -> Result<usize, ErrorCode> {
@@ -67,12 +82,31 @@ impl TxReviewer {
         self.buffer.write(amount_str)
     }
 
-    fn write_token_amount(&mut self, u256: &U256) -> Result<usize, ErrorCode> {
+    fn write_token_raw_amount(&mut self, u256: &U256) -> Result<usize, ErrorCode> {
         let mut amount_output = [0u8; 78]; // u256 max
         let amount_str = u256.to_str(&mut amount_output).unwrap();
         self.buffer.write(amount_str)
     }
 
+    fn write_token_amount(
+        &mut self,
+        u256: &U256,
+        symbol: TokenSymbol,
+        decimals: usize,
+    ) -> Result<usize, ErrorCode> {
+        let mut amount_output = [0u8; 86]; // u256 max
+        let symbol_bytes = get_token_symbol_bytes(&symbol[..]);
+        amount_output[..symbol_bytes.len()].copy_from_slice(symbol_bytes);
+        amount_output[symbol_bytes.len()] = b' ';
+        let prefix_length = symbol_bytes.len() + 1;
+        let amount_str = u256.to_str_with_decimals(&mut amount_output[prefix_length..], decimals);
+        if amount_str.is_none() {
+            return Err(ErrorCode::Overflow);
+        }
+        let total_length = prefix_length + amount_str.unwrap().len();
+        self.buffer.write(&amount_output[..total_length])
+    }
+
     fn write_token_id(&mut self, token_id: &Byte32) -> Result<usize, ErrorCode> {
         let hex_str: [u8; 64] = utils::to_hex(&token_id.0).unwrap();
         self.buffer.write(&hex_str)
@@ -188,6 +222,25 @@ impl TxReviewer {
         self.buffer.write(str_bytes)
     }
 
+    fn get_token_metadata(&self, token_id: &Hash) -> Option<(TokenSymbol, u8)> {
+        let token_size = self.token_metadata_length / TOKEN_METADATA_SIZE;
+        if token_size == 0 {
+            return None;
+        }
+        for i in 0..token_size {
+            let from_index = i * TOKEN_METADATA_SIZE;
+            let to_index = from_index + TOKEN_METADATA_SIZE;
+            let token_metadata_bytes = self.buffer.read(from_index, to_index);
+            if token_metadata_bytes[1..33] == token_id.0 {
+                let last_index = TOKEN_METADATA_SIZE - 1;
+                let token_symbol = token_metadata_bytes[33..last_index].try_into().unwrap();
+                let token_decimals = token_metadata_bytes[last_index];
+                return Some((token_symbol, token_decimals));
+            }
+        }
+        None
+    }
+
     fn prepare_output(
         &mut self,
         output: &AssetOutput,
@@ -228,21 +281,39 @@ impl TxReviewer {
 
         // Asset output has at most one token
         let token = output.tokens.get_current_item().unwrap();
-        let token_id_from_index = self.buffer.get_index();
-        let token_id_to_index = self.write_token_id(&token.id)?;
-
-        let token_amount_from_index = self.buffer.get_index();
-        let token_amount_to_index = self.write_token_amount(&token.amount)?;
-
+        let token_indexes = self.prepare_token(token)?;
         Ok(Some(OutputIndexes {
-            token: Some(TokenIndexes {
-                token_id: (token_id_from_index, token_id_to_index),
-                token_amount: (token_amount_from_index, token_amount_to_index),
-            }),
+            token: Some(token_indexes),
             ..output_indexes
         }))
     }
 
+    fn prepare_token(&mut self, token: &Token) -> Result<TokenIndexes, ErrorCode> {
+        let token_id_from_index = self.buffer.get_index();
+        let token_id_to_index = self.write_token_id(&token.id)?;
+        match self.get_token_metadata(&token.id) {
+            Some((token_symbol, token_decimals)) => {
+                let token_amount_from_index = self.buffer.get_index();
+                let token_amount_to_index =
+                    self.write_token_amount(&token.amount, token_symbol, token_decimals as usize)?;
+                Ok(TokenIndexes {
+                    has_token_metadata: true,
+                    token_id: (token_id_from_index, token_id_to_index),
+                    token_amount: (token_amount_from_index, token_amount_to_index),
+                })
+            }
+            None => {
+                let token_amount_from_index = self.buffer.get_index();
+                let token_amount_to_index = self.write_token_raw_amount(&token.amount)?;
+                Ok(TokenIndexes {
+                    has_token_metadata: false,
+                    token_id: (token_id_from_index, token_id_to_index),
+                    token_amount: (token_amount_from_index, token_amount_to_index),
+                })
+            }
+        }
+    }
+
     fn get_str_from_range(&self, range: (usize, usize)) -> Result<&str, ErrorCode> {
         let bytes = self.buffer.read(range.0, range.1);
         bytes_to_string(bytes)
@@ -310,23 +381,39 @@ impl TxReviewer {
         }
 
         let TokenIndexes {
+            has_token_metadata,
             token_id,
             token_amount,
         } = token.unwrap();
         let token_id = self.get_str_from_range(token_id)?;
         let token_amount = self.get_str_from_range(token_amount)?;
-        let fields = [
-            alph_amount_field,
-            Field {
-                name: "Token ID",
-                value: token_id,
-            },
-            Field {
-                name: "Raw Amount",
-                value: token_amount,
-            },
-            address_field,
-        ];
+        let fields = if has_token_metadata {
+            [
+                Field {
+                    name: "Token ID",
+                    value: token_id,
+                },
+                Field {
+                    name: "Token Amount",
+                    value: token_amount,
+                },
+                alph_amount_field,
+                address_field,
+            ]
+        } else {
+            [
+                Field {
+                    name: "Token ID",
+                    value: token_id,
+                },
+                Field {
+                    name: "Raw Amount",
+                    value: token_amount,
+                },
+                alph_amount_field,
+                address_field,
+            ]
+        };
         review(&fields, review_message)
     }
 
@@ -362,7 +449,7 @@ impl TxReviewer {
                 if let Some(current_output) = outputs.get_current_item() {
                     let result =
                         self.review_output(current_output, device_address, temp_data.read_all());
-                    self.reset_buffer();
+                    self.reset_buffer(self.token_metadata_length);
                     result
                 } else {
                     Ok(())
@@ -497,6 +584,7 @@ pub struct OutputIndexes {
 }
 
 pub struct TokenIndexes {
+    pub has_token_metadata: bool,
     pub token_id: (usize, usize),
     pub token_amount: (usize, usize),
 }
@@ -506,6 +594,15 @@ fn bytes_to_string(bytes: &[u8]) -> Result<&str, ErrorCode> {
     from_utf8(bytes).map_err(|_| ErrorCode::InternalError)
 }
 
+#[inline]
+fn get_token_symbol_bytes(bytes: &[u8]) -> &[u8] {
+    let mut index = 0;
+    while index < bytes.len() && bytes[index] != 0 {
+        index += 1;
+    }
+    &bytes[..index]
+}
+
 fn review<'a>(fields: &'a [Field<'a>], review_message: &str) -> Result<(), ErrorCode> {
     #[cfg(not(any(target_os = "stax", target_os = "flex")))]
     {