fix app submit review

src/app_ui/sign.rs

@@ -15,40 +15,44 @@
  *  limitations under the License.
  *****************************************************************************/
 use crate::cfx_addr::{cfx_addr_encode, Network};
-use crate::types::Transaction;
+use crate::types::{Transaction, U256};
 use crate::AppSW;
 
 #[cfg(not(any(target_os = "stax", target_os = "flex")))]
 use ledger_device_sdk::ui::{
     bitmaps::{CROSSMARK, EYE, VALIDATE_14},
-    gadgets::{Field, MultiFieldReview},
+    gadgets::{clear_screen, Field, MultiFieldReview, Page},
 };
 
-#[cfg(any(target_os = "stax", target_os = "flex"))]
 use crate::settings::Settings;
 #[cfg(any(target_os = "stax", target_os = "flex"))]
 use include_gif::include_gif;
 #[cfg(any(target_os = "stax", target_os = "flex"))]
-use ledger_device_sdk::nbgl::{Field, NbglGlyph, NbglReview};
+use ledger_device_sdk::nbgl::{Field, NbglChoice, NbglGlyph, NbglReview};
 
-use alloc::format;
+use alloc::{format, vec};
 
 /// Displays a transaction and returns true if user approved it.
 ///
-/// This method can return [`AppSW::TxDisplayFail`] error if the coin name length is too long.
+/// This method can return [`AppSW::TxDisplayFail`] error
 ///
 /// # Arguments
 ///
 /// * `tx` - Transaction to be displayed for validation
 pub fn ui_display_tx(tx: &Transaction) -> Result<bool, AppSW> {
+    let fully_decoded = tx.fully_decoded();
+
     let value_str = tx.value.cfx_str().ok_or(AppSW::TxDisplayFail)?;
-    let value_with_unit = format!("CFX {}", value_str);
+    let value_with_unit = format!("{} CFX", value_str);
+
     let network = Network::from_network_id(tx.chain_id);
     let to_str = cfx_addr_encode(&*tx.to, network).map_err(|_e| AppSW::AddrDisplayFail)?;
-    let data_str = format!("0x{}", hex::encode(tx.data.clone()).to_uppercase());
+
+    let fee_str = tx.max_gas_fee().cfx_str().ok_or(AppSW::TxDisplayFail)?;
+    let fee_with_unit = format!("{} CFX", fee_str);
 
     // Define transaction review fields
-    let my_fields = [
+    let mut my_fields = vec![
         Field {
             name: "Amount",
             value: value_with_unit.as_str(),
@@ -58,14 +62,40 @@ pub fn ui_display_tx(tx: &Transaction) -> Result<bool, AppSW> {
             value: to_str.as_str(),
         },
         Field {
-            name: "Data",
-            value: data_str.as_str(),
+            name: "Max Gas Fees",
+            value: fee_with_unit.as_str(),
         },
     ];
 
+    let storage_fee_str = tx.max_storage_fee().cfx_str().ok_or(AppSW::TxDisplayFail)?;
+    let storage_fee_with_unit = format!("{} CFX", storage_fee_str);
+    if tx.max_storage_fee() > U256::zero() {
+        my_fields.push(Field {
+            name: "Max Storage Fees",
+            value: storage_fee_with_unit.as_str(),
+        });
+    }
+
+    let data_str = format!("0x{}", hex::encode(tx.data.clone()).to_uppercase());
+    my_fields.push(Field {
+        name: "Data",
+        value: data_str.as_str(),
+    });
+
+    let settings: Settings = Default::default();
+
     // Create transaction review
     #[cfg(not(any(target_os = "stax", target_os = "flex")))]
     {
+        if !fully_decoded && settings.get_element(0)? == 0 {
+            // show warning and return
+            let warning =
+                Page::from((["Blind signing must", "be enabled in Settings"], &CROSSMARK));
+            clear_screen();
+            warning.place_and_wait();
+            return Ok(false);
+        }
+
         let my_review = MultiFieldReview::new(
             &my_fields,
             &["Review ", "Transaction"],
@@ -75,28 +105,40 @@ pub fn ui_display_tx(tx: &Transaction) -> Result<bool, AppSW> {
             "Reject",
             Some(&CROSSMARK),
         );
-
         Ok(my_review.show())
     }
 
     #[cfg(any(target_os = "stax", target_os = "flex"))]
     {
+        if !fully_decoded && settings.get_element(0)? == 0 {
+            let _confirmed = NbglChoice::new().show(
+                "This transaction cannot be clear-signed",
+                "Enable blind signing in the settings to sign this transaction.",
+                "Go to settings",
+                "Reject transaction",
+            );
+            return Ok(false);
+        }
         // Load glyph from 64x64 4bpp gif file with include_gif macro. Creates an NBGL compatible glyph.
         const CFX: NbglGlyph = NbglGlyph::from_include(include_gif!("icons/cfx_64.gif", NBGL));
         // Create NBGL review. Maximum number of fields and string buffer length can be customised
         // with constant generic parameters of NbglReview. Default values are 32 and 1024 respectively.
-        let review: NbglReview = NbglReview::new()
+        let mut review: NbglReview = NbglReview::new()
             .titles(
                 "Review transaction\nto send CFX",
                 "",
                 "Sign transaction\nto send CFX",
             )
             .glyph(&CFX);
 
-        // If first setting switch is disabled do not display the transaction data
-        let settings: Settings = Default::default();
+        if !fully_decoded {
+            review = review.blind();
+        }
+
+        // If second setting switch is disabled do not display the transaction data
         if settings.get_element(1)? == 0 {
-            Ok(review.show(&my_fields[0..2]))
+            let field_len = my_fields.len() - 1;
+            Ok(review.show(&my_fields[0..field_len]))
         } else {
             Ok(review.show(&my_fields))
         }

src/consts.rs

@@ -18,3 +18,8 @@ pub const EXPONENT_SMALLEST_UNIT: usize = 18;
 pub const APP_FLAG_BLIND_SIGNING_ENABLED: u8 = 0x01;
 
 pub const APP_FLAG_DETAILED_DISPLAY_ENABLED: u8 = 0x02;
+
+/**
+ * One CFX that can be paid for storage.
+ */
+pub const STORAGE_OF_ONE_CFX: u64 = 1024;

src/types/primitives.rs

@@ -56,6 +56,26 @@ impl Decodable for H256 {
 #[derive(Debug, Clone, Default, PartialEq, Eq)]
 pub struct Address(pub [u8; ADDRRESS_BYTES_LEN]);
 
+impl Address {
+    pub fn address_type(&self) -> u8 {
+        self.0[0] & 0xf0
+    }
+
+    pub fn is_user_address(&self) -> bool {
+        self.address_type() == 0x10
+    }
+
+    #[allow(unused)]
+    pub fn is_contract_address(&self) -> bool {
+        self.address_type() == 0x80
+    }
+
+    #[allow(unused)]
+    pub fn is_builtin_address(&self) -> bool {
+        self.address_type() == 0x00
+    }
+}
+
 impl Decodable for Address {
     fn decode(rlp: &Rlp) -> Result<Self, DecoderError> {
         rlp.decoder()

src/types/transaction.rs

@@ -1,9 +1,11 @@
 use super::{Address, H256, U256};
+use crate::consts::STORAGE_OF_ONE_CFX;
 use alloc::vec::Vec;
 use rlp_decoder::{Decodable, DecoderError, Rlp};
 
 pub const TX_RLP_PREFIX_2930: [u8; 4] = [0x63, 0x66, 0x78, 0x01]; // "cfx" + 1
 pub const TX_RLP_PREFIX_1559: [u8; 4] = [0x63, 0x66, 0x78, 0x02]; // "cfx" + 2
+pub const ONE_CFX_IN_DRIP: u64 = 1_000_000_000_000_000_000;
 
 #[derive(Debug, Default, Clone)]
 pub struct Transaction {
@@ -21,6 +23,28 @@ pub struct Transaction {
     pub max_fee_per_gas: Option<U256>,
 }
 
+impl Transaction {
+    pub fn max_gas_fee(&self) -> U256 {
+        if self.gas_price.is_some() {
+            self.gas_price.unwrap() * U256::from(self.gas)
+        } else {
+            self.max_fee_per_gas.unwrap() * U256::from(self.gas)
+        }
+    }
+
+    pub fn max_storage_fee(&self) -> U256 {
+        U256::from(self.storage_limit) * U256::from(ONE_CFX_IN_DRIP)
+            / U256::from(STORAGE_OF_ONE_CFX)
+    }
+
+    // whether the tx is fully decoded
+    // when the tx is to a contract address, the data field is not empty
+    // we call it not fully decoded
+    pub fn fully_decoded(&self) -> bool {
+        self.data.len() == 0 || self.to.is_user_address()
+    }
+}
+
 #[derive(Debug, Clone, Default, PartialEq, Eq)]
 pub struct AccessListItem {
     pub address: Address,