Store FMD flag ciphertexts in extra data secs

Author: sug0

crates/node/src/bench_utils.rs

@@ -192,7 +192,7 @@ impl BenchShellInner {
 
         if let Some(sections) = extra_sections {
             for section in sections {
-                if let Section::ExtraData(_) | Section::Data(_) = section {
+                if let Section::ExtraData(_) = section {
                     tx.add_section(section);
                 }
             }
@@ -1098,9 +1098,13 @@ impl Client for BenchShell {
                     });
                 let masp_fmd_event =
                     tx.sections.iter().find_map(|section| match section {
-                        sec @ Section::Data(Data { data, .. })
-                            if <Vec<FlagCiphertext>>::try_from_slice(data)
-                                .is_ok() =>
+                        sec @ Section::ExtraData(extra_data)
+                            if extra_data.id().is_some_and(|extra_data| {
+                                <Vec<FlagCiphertext>>::try_from_slice(
+                                    extra_data,
+                                )
+                                .is_ok()
+                            }) =>
                         {
                             Some(AbciEvent::from(Event::from(
                                 MaspEvent::FlagCiphertexts {
@@ -1312,7 +1316,8 @@ impl BenchShieldedCtx {
             )
             .expect("MASP must have shielded part");
 
-        let fmd_section = Section::Data(Data::from_borsh_encoded(&fmd_flags));
+        let fmd_section =
+            Section::ExtraData(Code::from_borsh_encoded(&fmd_flags));
         let shielded_data = MaspTxData {
             masp_tx_id: shielded.txid().into(),
             flag_ciphertext_sechash: fmd_section.get_hash(),
@@ -1430,7 +1435,7 @@ impl BenchShieldedCtx {
                 .into_iter()
                 .collect();
         let masp_tx = tx.tx.get_masp_section(&masp_tx_id).unwrap().clone();
-        let fmd_section = Section::Data(Data::from_borsh_encoded(
+        let fmd_section = Section::ExtraData(Code::from_borsh_encoded(
             &std::iter::repeat_with(FlagCiphertext::default)
                 .take(
                     masp_tx

crates/sdk/src/lib.rs

@@ -901,7 +901,7 @@ pub mod testing {
         arb_withdraw,
     };
     use crate::tx::{
-        Authorization, Code, Commitment, Data, Header, MaspBuilder, Section,
+        Authorization, Code, Commitment, Header, MaspBuilder, Section,
         TxCommitments,
     };
 
@@ -1146,10 +1146,8 @@ pub mod testing {
             if let Some((shielded_transfer, asset_types, build_params)) = aux {
                 let shielded_section_hash =
                     tx.add_masp_tx_section(shielded_transfer.masp_tx).1;
-                tx.add_section(
-                    Section::Data(
-                        Data::from_borsh_encoded(&shielded_transfer.fmd_flags),
-                    ),
+                tx.add_fmd_flag_ciphertexts(
+                    &shielded_transfer.fmd_flags,
                 );
                 tx.add_masp_builder(MaspBuilder {
                     asset_types: asset_types.into_keys().collect(),

crates/sdk/src/tx.rs

@@ -4351,7 +4351,7 @@ fn proposal_to_vec(proposal: OnChainProposal) -> Result<Vec<u8>> {
 }
 
 fn create_fmd_section(fmd_flags: Vec<FlagCiphertext>) -> (Section, Hash) {
-    let fmd_section = Section::Data(Data::from_borsh_encoded(&fmd_flags));
+    let fmd_section = Section::ExtraData(Code::from_borsh_encoded(&fmd_flags));
     let fmd_sechash = fmd_section.get_hash();
 
     (fmd_section, fmd_sechash)

crates/token/src/lib.rs

@@ -536,8 +536,8 @@ pub mod testing {
             .take(builder.sapling_outputs().len())
             .collect();
             let fmd_sechash = {
-                let sec = namada_tx::Section::Data(
-                    namada_tx::Data::from_borsh_encoded(&fmd_flags),
+                let sec = namada_tx::Section::ExtraData(
+                    namada_tx::Code::from_borsh_encoded(&fmd_flags),
                 );
                 sec.get_hash()
             };

crates/tx/src/section.rs

@@ -277,7 +277,7 @@ impl Data {
 
     /// Make a new data section with the given borsh encodable data
     #[inline]
-    pub fn from_borsh_encoded<T: BorshSerialize>(data: &T) -> Self {
+    pub fn from_borsh_encoded<T: BorshSerialize + ?Sized>(data: &T) -> Self {
         Self::new(data.serialize_to_vec())
     }
 
@@ -376,6 +376,21 @@ impl Code {
         }
     }
 
+    /// Return the code data, if it is present verbatim.
+    pub fn id(&self) -> Option<&[u8]> {
+        if let Commitment::Id(code) = &self.code {
+            Some(&code[..])
+        } else {
+            None
+        }
+    }
+
+    /// Make a new code section with the given borsh encodable data
+    #[inline]
+    pub fn from_borsh_encoded<T: BorshSerialize + ?Sized>(data: &T) -> Self {
+        Self::new(data.serialize_to_vec(), None)
+    }
+
     /// Make a new code section with the given hash
     pub fn from_hash(
         hash: namada_core::hash::Hash,

crates/tx/src/types.rs

@@ -290,23 +290,40 @@ impl Tx {
         None
     }
 
+    /// Add an FMD flag ciphertext section to the transaction
+    pub fn add_fmd_flag_ciphertexts(
+        &mut self,
+        flag_ciphertexts: &[FlagCiphertext],
+    ) -> &mut Self {
+        self.add_section(Section::ExtraData(Code::from_borsh_encoded(
+            flag_ciphertexts,
+        )));
+        self
+    }
+
     /// Get the FMD flag ciphertext with the given hash
     pub fn get_fmd_flag_ciphertexts(
         &self,
         hash: &namada_core::hash::Hash,
     ) -> Result<Option<Vec<FlagCiphertext>>, DecodeError> {
         let maybe_section = self.get_section(hash);
 
-        let data = match maybe_section.as_ref().map(Cow::as_ref) {
-            Some(Section::Data(Data { data, .. })) => data,
-            Some(_) => {
+        let code = match maybe_section.as_ref().map(Cow::as_ref) {
+            Some(Section::ExtraData(code)) => code,
+            Some(sec) => {
                 return Err(DecodeError::InvalidFlagCiphertexts(
                     HEXUPPER.encode(&hash.0),
                 ));
             }
             None => return Ok(None),
         };
 
+        let Some(data) = code.id() else {
+            return Err(DecodeError::InvalidFlagCiphertexts(
+                HEXUPPER.encode(&hash.0),
+            ));
+        };
+
         let decoded =
             BorshDeserialize::try_from_slice(data).map_err(|_err| {
                 DecodeError::InvalidFlagCiphertexts(HEXUPPER.encode(&hash.0))