Use of heap feature for simpler code

.cargo/config.toml

@@ -5,5 +5,5 @@ runner = "speculos -a=1 --model=nanosp"
 target = "nanosplus"
 
 [unstable]
-build-std = ["core"]
+build-std = ["core", "alloc"]
 build-std-features = ["compiler-builtins-mem"]

Cargo.toml

@@ -5,11 +5,11 @@ authors = ["yhql", "agrojean-ledger"]
 edition = "2021"
 
 [dependencies]
-ledger_device_sdk = "1.9.2"
+ledger_device_sdk = { version="1.10.0", features = ["heap"] }
 include_gif = "1.1.0"
 serde = {version="1.0.192", default_features = false, features = ["derive"]}
 serde-json-core = { git = "https://github.com/rust-embedded-community/serde-json-core"}
-hex = { version = "0.4.3", default-features = false, features = ["serde"] }
+hex = { version = "0.4.3", default-features = false, features = ["serde", "alloc"] }
 numtoa = "0.2.4"
 
 [profile.release]

src/app_ui/address.rs

@@ -16,6 +16,7 @@
  *****************************************************************************/
 
 use crate::AppSW;
+use alloc::format;
 use core::str::from_utf8_mut;
 
 #[cfg(not(any(target_os = "stax", target_os = "flex")))]
@@ -34,15 +35,10 @@ use include_gif::include_gif;
 const DISPLAY_ADDR_BYTES_LEN: usize = 20;
 
 pub fn ui_display_pk(addr: &[u8]) -> Result<bool, AppSW> {
- let mut addr_hex = [0u8; DISPLAY_ADDR_BYTES_LEN * 2 + 2];
- addr_hex[..2].copy_from_slice("0x".as_bytes());
- hex::encode_to_slice(
- &addr[addr.len() - DISPLAY_ADDR_BYTES_LEN..],
- &mut addr_hex[2..],
- )
- .unwrap();
- let addr_hex = from_utf8_mut(&mut addr_hex).unwrap();
- addr_hex[2..].make_ascii_uppercase();
+ let addr_hex = format!(
+ "0x{}",
+ hex::encode(&addr[addr.len() - DISPLAY_ADDR_BYTES_LEN..]).to_uppercase()
+ );
 
  #[cfg(not(any(target_os = "stax", target_os = "flex")))]
  {

src/app_ui/sign.rs

@@ -15,7 +15,6 @@
  * limitations under the License.
  *****************************************************************************/
 use crate::handlers::sign_tx::Tx;
-use crate::utils::concatenate;
 use crate::AppSW;
 
 #[cfg(not(any(target_os = "stax", target_os = "flex")))]
@@ -35,6 +34,8 @@ use numtoa::NumToA;
 
 const MAX_COIN_LENGTH: usize = 10;
 
+use alloc::format;
+
 /// 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.
@@ -43,31 +44,18 @@ const MAX_COIN_LENGTH: usize = 10;
 ///
 /// * `tx` - Transaction to be displayed for validation
 pub fn ui_display_tx(tx: &Tx) -> Result<bool, AppSW> {
- // Generate string for amount
- let mut numtoa_buf = [0u8; 20];
- let mut value_buf = [0u8; 20 + MAX_COIN_LENGTH + 1];
-
- let value_str = concatenate(
- &[tx.coin, " ", tx.value.numtoa_str(10, &mut numtoa_buf)],
- &mut value_buf,
- )
- .map_err(|_| AppSW::TxDisplayFail)?; // Fails if value_buf is too small
-
- // Generate destination address string in hexadecimal format.
- let mut to_str = [0u8; 42];
- to_str[..2].copy_from_slice("0x".as_bytes());
- hex::encode_to_slice(tx.to, &mut to_str[2..]).unwrap();
- to_str[2..].make_ascii_uppercase();
+ let value_str = format!("{} {}", tx.coin, tx.value);
+ let to_str = format!("0x{}", hex::encode(tx.to).to_uppercase());
 
  // Define transaction review fields
  let my_fields = [
  Field {
  name: "Amount",
- value: value_str,
+ value: value_str.as_str(),
  },
  Field {
  name: "Destination",
- value: core::str::from_utf8(&to_str).unwrap(),
+ value: to_str.as_str(),
  },
  Field {
  name: "Memo",

src/handlers/sign_tx.rs

@@ -17,6 +17,7 @@
 use crate::app_ui::sign::ui_display_tx;
 use crate::utils::Bip32Path;
 use crate::AppSW;
+use alloc::vec::Vec;
 use ledger_device_sdk::ecc::{Secp256k1, SeedDerive};
 use ledger_device_sdk::hash::{sha3::Keccak256, HashInit};
 use ledger_device_sdk::io::Comm;
@@ -38,24 +39,21 @@ pub struct Tx<'a> {
 }
 
 pub struct TxContext {
- raw_tx: [u8; MAX_TRANSACTION_LEN], // raw transaction serialized
- raw_tx_len: usize, // length of raw transaction
+ raw_tx: Vec<u8>,
  path: Bip32Path,
 }
 
 // Implement constructor for TxInfo with default values
 impl TxContext {
  pub fn new() -> TxContext {
  TxContext {
- raw_tx: [0u8; MAX_TRANSACTION_LEN],
- raw_tx_len: 0,
+ raw_tx: Vec::new(),
  path: Default::default(),
  }
  }
  // Implement reset for TxInfo
  fn reset(&mut self) {
- self.raw_tx = [0u8; MAX_TRANSACTION_LEN];
- self.raw_tx_len = 0;
+ self.raw_tx.clear();
  self.path = Default::default();
  }
 }
@@ -78,22 +76,20 @@ pub fn handler_sign_tx(
  // Next chunks, append data to raw_tx and return or parse
  // the transaction if it is the last chunk.
  } else {
- if ctx.raw_tx_len + data.len() > MAX_TRANSACTION_LEN {
+ if ctx.raw_tx.len() + data.len() > MAX_TRANSACTION_LEN {
  return Err(AppSW::TxWrongLength);
  }
 
  // Append data to raw_tx
- ctx.raw_tx[ctx.raw_tx_len..ctx.raw_tx_len + data.len()].copy_from_slice(data);
- ctx.raw_tx_len += data.len();
+ ctx.raw_tx.extend(data);
 
  // If we expect more chunks, return
  if more {
  Ok(())
  // Otherwise, try to parse the transaction
  } else {
  // Try to deserialize the transaction
- let (tx, _): (Tx, usize) =
- from_slice(&ctx.raw_tx[..ctx.raw_tx_len]).map_err(|_| AppSW::TxParsingFail)?;
+ let (tx, _): (Tx, usize) = from_slice(&ctx.raw_tx).map_err(|_| AppSW::TxParsingFail)?;
  // Display transaction. If user approves
  // the transaction, sign it. Otherwise,
  // return a "deny" status word.
@@ -110,7 +106,7 @@ fn compute_signature_and_append(comm: &mut Comm, ctx: &mut TxContext) -> Result<
  let mut keccak256 = Keccak256::new();
  let mut message_hash: [u8; 32] = [0u8; 32];
 
- let _ = keccak256.hash(&ctx.raw_tx[..ctx.raw_tx_len], &mut message_hash);
+ let _ = keccak256.hash(&ctx.raw_tx, &mut message_hash);
 
  let (sig, siglen, parity) = Secp256k1::derive_from_path(ctx.path.as_ref())
  .deterministic_sign(&message_hash)

src/main.rs

@@ -45,6 +45,9 @@ use ledger_device_sdk::ui::gadgets::display_pending_review;
 #[cfg(not(any(target_os = "stax", target_os = "flex")))]
 ledger_device_sdk::set_panic!(ledger_device_sdk::exiting_panic);
 
+// Required for using String, Vec, format!...
+extern crate alloc;
+
 #[cfg(any(target_os = "stax", target_os = "flex"))]
 use ledger_device_sdk::nbgl::init_comm;
 

src/utils.rs

@@ -1,79 +1,42 @@
+use alloc::vec::Vec;
+
 use crate::AppSW;
-use core::str::from_utf8;
 
 /// BIP32 path stored as an array of [`u32`].
-///
-/// # Generic arguments
-///
-/// * `S` - Maximum possible path length, i.e. the capacity of the internal buffer.
-pub struct Bip32Path<const S: usize = 10> {
- buffer: [u32; S],
- len: usize,
-}
+#[derive(Default)]
+pub struct Bip32Path(Vec<u32>);
 
 impl AsRef<[u32]> for Bip32Path {
  fn as_ref(&self) -> &[u32] {
- &self.buffer[..self.len]
- }
-}
-
-impl<const S: usize> Default for Bip32Path<S> {
- fn default() -> Self {
- Self {
- buffer: [0u32; S],
- len: 0,
- }
+ &self.0
  }
 }
 
-impl<const S: usize> TryFrom<&[u8]> for Bip32Path<S> {
+impl TryFrom<&[u8]> for Bip32Path {
  type Error = AppSW;
 
  /// Constructs a [`Bip32Path`] from a given byte array.
  ///
  /// This method will return an error in the following cases:
  /// - the input array is empty,
  /// - the number of bytes in the input array is not a multiple of 4,
- /// - the input array exceeds the capacity of the [`Bip32Path`] internal buffer.
  ///
  /// # Arguments
  ///
  /// * `data` - Encoded BIP32 path. First byte is the length of the path, as encoded by ragger.
  fn try_from(data: &[u8]) -> Result<Self, Self::Error> {
- let input_path_len = (data.len() - 1) / 4;
  // Check data length
  if data.is_empty() // At least the length byte is required
- || (input_path_len > S)
  || (data[0] as usize * 4 != data.len() - 1)
  {
  return Err(AppSW::WrongApduLength);
  }
 
- let mut path = [0; S];
- for (chunk, p) in data[1..].chunks(4).zip(path.iter_mut()) {
- *p = u32::from_be_bytes(chunk.try_into().unwrap());
- }
-
- Ok(Self {
- buffer: path,
- len: input_path_len,
- })
+ Ok(Bip32Path(
+ data[1..]
+ .chunks(4)
+ .map(|chunk| u32::from_be_bytes(chunk.try_into().unwrap()))
+ .collect(),
+ ))
  }
 }
-
-/// Returns concatenated strings, or an error if the concatenation buffer is too small.
-pub fn concatenate<'a>(strings: &[&str], output: &'a mut [u8]) -> Result<&'a str, ()> {
- let mut offset = 0;
-
- for s in strings {
- let s_len = s.len();
- if offset + s_len > output.len() {
- return Err(());
- }
-
- output[offset..offset + s_len].copy_from_slice(s.as_bytes());
- offset += s_len;
- }
-
- Ok(from_utf8(&output[..offset]).unwrap())
-}