Some improvements to avoid panicking and enhance remainder handling i…

…n case of multisig transactions

More improvements in project structure

Ensure to parse all contract arguments avoiding potential errors during transaction review

Increase recursion limit to 8 nested clarity values, this does not hit any limits regarding nanos2

add snapshots

feat/ add debug implementation

Restructure the post-conditions into its own folder and module

Update zxformat to use ledger-zxlib when compiling to ledger targets

Add test to parsed transaction containing post-conditions

Bump app version

app/Makefile.version

@@ -1,3 +1,3 @@
 APPVERSION_M=0
 APPVERSION_N=24
-APPVERSION_P=4
+APPVERSION_P=5

app/rust/Cargo.toml

@@ -23,6 +23,9 @@ hex = { version = "0.4", default-features = false }
 serde-json-core = { version = "0.4.0", default-features = false }
 serde = { version = "1.0", default-features = false, features = ["derive"] }
 nom = { version = "7.1.2", default-features = false }
+lexical-core = { version = "0.7", features = [
+    "libm",
+], default-features = false }
 
 
 [dependencies.arrayvec]

app/rust/src/parser/ffi.rs

@@ -225,9 +225,12 @@ pub unsafe extern "C" fn _last_block_ptr(
 ) -> u16 {
     if let Some(tx) = parsed_obj_from_state(tx_t as _).and_then(|obj| obj.transaction()) {
         let block = tx.last_transaction_block();
+
         *block_ptr = block.as_ptr();
         return block.len() as _;
     }
+
+    *block_ptr = core::ptr::null_mut();
     0
 }
 

app/rust/src/parser/message.rs

@@ -12,6 +12,7 @@ const BYTE_STRING_HEADER_LEN: usize = "\x17Stacks Signed Message:\n".as_bytes().
 const MAX_ASCII_LEN: usize = 270;
 
 #[repr(C)]
+#[cfg_attr(test, derive(Debug))]
 pub struct Message<'a>(ByteString<'a>);
 
 impl<'a> Message<'a> {
@@ -45,9 +46,20 @@ impl<'a> Message<'a> {
 }
 
 #[repr(C)]
-#[derive(Debug, Copy, Clone, PartialEq)]
+#[derive(Copy, Clone, PartialEq)]
 pub struct ByteString<'a>(&'a [u8]);
 
+#[cfg(test)]
+impl<'a> core::fmt::Debug for ByteString<'a> {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        write!(f, "ByteString(\"")?;
+        for byte in self.0 {
+            write!(f, "{:02x}", byte)?;
+        }
+        write!(f, "\")")
+    }
+}
+
 impl<'a> ByteString<'a> {
     pub fn is_msg(data: &'a [u8]) -> bool {
         Self::contain_header(data)

app/rust/src/parser/mod.rs

@@ -5,13 +5,14 @@ mod jwt;
 mod message;
 mod parsed_obj;
 mod parser_common;
-mod post_condition;
+mod post_conditions;
 mod principal;
 mod spending_condition;
 mod structured_msg;
 mod transaction;
 mod transaction_auth;
 mod transaction_payload;
+mod tx_post_conditions;
 mod utils;
 mod value;
 pub use error::ParserError;
@@ -20,10 +21,11 @@ pub use jwt::Jwt;
 pub use message::{ByteString, Message};
 pub use parsed_obj::{ParsedObj, Tag};
 pub use parser_common::*;
-pub use post_condition::{FungibleConditionCode, TransactionPostCondition};
+pub use post_conditions::{FungibleConditionCode, TransactionPostCondition};
 pub use principal::*;
 pub use structured_msg::{Domain, StructuredMsg};
 pub use transaction::Transaction;
 pub use transaction_auth::TransactionAuth;
+pub use tx_post_conditions::{PostConditions, TransactionPostConditionMode};
 pub use utils::*;
 pub use value::{Int128, Tuple, UInt128, Value, ValueId};

app/rust/src/parser/parsed_obj.rs

@@ -1,5 +1,7 @@
 #![allow(non_camel_case_types, non_snake_case, clippy::missing_safety_doc)]
 
+use crate::bolos::c_zemu_log_stack;
+
 use super::{error::ParserError, transaction::Transaction, Message};
 use super::{Jwt, StructuredMsg};
 
@@ -56,6 +58,7 @@ impl<'a> ParsedObj<'a> {
     }
 
     pub fn read(&mut self, data: &'a [u8]) -> Result<(), ParserError> {
+        c_zemu_log_stack("ParsedObj::read\x00");
         if data.is_empty() {
             return Err(ParserError::NoData);
         }
@@ -65,15 +68,19 @@ impl<'a> ParsedObj<'a> {
 
         unsafe {
             if Message::is_message(data) {
+                c_zemu_log_stack("Tag::Msg\x00");
                 self.tag = Tag::Message;
                 self.obj.read_msg(data)
             } else if Jwt::is_jwt(data) {
+                c_zemu_log_stack("Tag::Jwt\x00");
                 self.tag = Tag::Jwt;
                 self.obj.read_jwt(data)
             } else if StructuredMsg::is_msg(data) {
+                c_zemu_log_stack("Tag::StructuredMsg\x00");
                 self.tag = Tag::StructuredMsg;
                 self.obj.read_structured_msg(data)
             } else {
+                c_zemu_log_stack("Tag::Transaction\x00");
                 self.tag = Tag::Transaction;
                 self.obj.read_tx(data)
             }
@@ -99,6 +106,7 @@ impl<'a> ParsedObj<'a> {
         value: &mut [u8],
         page_idx: u8,
     ) -> Result<u8, ParserError> {
+        c_zemu_log_stack("ParsedObj::get_item\x00");
         unsafe {
             match self.tag {
                 Tag::Transaction => {
@@ -259,6 +267,38 @@ impl<'a> Obj<'a> {
     }
 }
 
+#[cfg(test)]
+impl<'a> core::fmt::Debug for ParsedObj<'a> {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        let mut debug_struct = f.debug_struct("ParsedObj");
+        debug_struct.field("tag", &self.tag);
+
+        // Safety: We're matching on the tag to ensure we access the correct
+        // union variant. The union is guaranteed to be initialized with the
+        // correct variant and that variant won't change during the lifetime
+        // of the object.
+        match self.tag {
+            Tag::Transaction => unsafe {
+                debug_struct.field("obj", &self.obj.tx);
+            },
+            Tag::Message => unsafe {
+                debug_struct.field("obj", &self.obj.msg);
+            },
+            Tag::Jwt => unsafe {
+                debug_struct.field("obj", &self.obj.jwt);
+            },
+            Tag::StructuredMsg => unsafe {
+                debug_struct.field("obj", &self.obj.structured_msg);
+            },
+            Tag::Invalid => {
+                debug_struct.field("obj", &"<invalid>");
+            }
+        }
+
+        debug_struct.finish()
+    }
+}
+
 #[cfg(test)]
 mod test {
     use serde::{Deserialize, Serialize};
@@ -793,4 +833,17 @@ mod test {
         msg.read(&bytes).unwrap();
         ParsedObj::validate(&mut msg).unwrap();
     }
+
+    #[test]
+    fn test_swap_tx() {
+        let input = "000000000104009ef3889fd070159edcd8ef88a0ec87cea1592c83000000000000000000000000000f42400000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000302000000060002169ef3889fd070159edcd8ef88a0ec87cea1592c830100000000000027100003167c5f674a8fd08efa61dd9b11121e046dd2c892730a756e6976322d636f72650300000000000000000103167c5f674a8fd08efa61dd9b11121e046dd2c892730a756e6976322d636f7265168c5e2f8d25627d6edebeb6d10fa3300f5acc8441086c6f6e67636f696e086c6f6e67636f696e0300000000000000000103167c5f674a8fd08efa61dd9b11121e046dd2c892730a756e6976322d636f7265168c5e2f8d25627d6edebeb6d10fa3300f5acc8441086c6f6e67636f696e086c6f6e67636f696e0300000000000000000102169ef3889fd070159edcd8ef88a0ec87cea1592c83168c5e2f8d25627d6edebeb6d10fa3300f5acc8441086c6f6e67636f696e086c6f6e67636f696e030000000000000000010316402da2c079e5d31d58b9cfc7286d1b1eb2f7834e0f616d6d2d7661756c742d76322d303116402da2c079e5d31d58b9cfc7286d1b1eb2f7834e0a746f6b656e2d616c657804616c65780300000000011c908a02162ec1a2dc2904ebc8b408598116c75e42c51afa2617726f757465722d76656c61722d616c65782d762d312d320d737761702d68656c7065722d6100000007010000000000000000000000000000271001000000000000000000000000011c908a040c00000002016106167c5f674a8fd08efa61dd9b11121e046dd2c892730477737478016206168c5e2f8d25627d6edebeb6d10fa3300f5acc8441086c6f6e67636f696e06167c5f674a8fd08efa61dd9b11121e046dd2c8927312756e6976322d73686172652d6665652d746f0c0000000201610616402da2c079e5d31d58b9cfc7286d1b1eb2f7834e0b746f6b656e2d776c6f6e6701620616402da2c079e5d31d58b9cfc7286d1b1eb2f7834e0a746f6b656e2d616c65780c0000000101610100000000000000000000000005f5e100";
+        let bytes = hex::decode(input).unwrap();
+        let mut msg = ParsedObj::from_bytes(&bytes).unwrap();
+
+        msg.read(&bytes).unwrap();
+
+        ParsedObj::validate(&mut msg).unwrap();
+
+        std::println!("tx: {:?}", msg);
+    }
 }

app/rust/src/parser/parser_common.rs

@@ -20,11 +20,12 @@ pub const C32_ENCODED_ADDRS_LENGTH: usize = 48;
 pub const NUM_SUPPORTED_POST_CONDITIONS: usize = 16;
 pub const SIGNATURE_LEN: usize = 65;
 pub const PUBKEY_LEN: usize = 33;
-pub const TOKEN_TRANSFER_MEMO_LEN: usize = 34;
+pub const MEMO_LEN: usize = 34;
+pub const AMOUNT_LEN: usize = 8;
 
 // A recursion limit use to control ram usage when parsing
 // contract-call arguments that comes in a transaction
-pub const TX_DEPTH_LIMIT: u8 = 3;
+pub const TX_DEPTH_LIMIT: u8 = 8;
 
 // Use to limit recursion when parsing nested clarity values that comes as part of a structured
 // message. the limit is higher than the one use when parsing contract-args in transactions