pset: input: insert non-pset proprietary keys

src/pset/elip101.rs

@@ -67,6 +67,7 @@ impl Output {
 #[cfg(test)]
 mod test {
     use super::*;
+    use crate::AssetId;
     use crate::encode::{serialize_hex, Encodable};
     use crate::hex::{FromHex, ToHex};
 
@@ -110,4 +111,30 @@ mod test {
         assert!(output_hex.contains(ELIP0101_IDENTIFIER));
         assert!(output_hex.contains(abf_hex));
     }
+
+    #[test]
+    fn abf_roundtrip() {
+        use crate::pset::PartiallySignedTransaction;
+
+        // Set abf on an input and on an output
+        let abf = AssetBlindingFactor::from_slice(&[3; 32]).unwrap();
+        let mut pset = PartiallySignedTransaction::new_v2();
+        let mut input = Input::default();
+        input.set_abf(abf);
+        pset.add_input(input);
+        let mut output = Output {
+            amount: Some(1),
+            asset: Some(AssetId::from_slice(&[9; 32]).unwrap()),
+            ..Default::default()
+        };
+        output.set_abf(abf);
+        pset.add_output(output);
+
+        // Serialize and deserialize
+        let bytes = encode::serialize(&pset);
+        let pset_back = encode::deserialize::<PartiallySignedTransaction>(&bytes).unwrap();
+        // Check the abf
+        assert_eq!(pset_back.inputs()[0].get_abf().unwrap().unwrap(), abf);
+        assert_eq!(pset_back.outputs()[0].get_abf().unwrap().unwrap(), abf);
+    }
 }

src/pset/map/input.rs

@@ -759,8 +759,18 @@ impl Map for Input {
                             Entry::Occupied(_) => return Err(Error::DuplicateKey(raw_key).into()),
                         },
                     }
+                } else {
+                    match self.proprietary.entry(prop_key) {
+                        Entry::Vacant(empty_key) => {
+                            empty_key.insert(raw_value);
+                        }
+                        Entry::Occupied(_) => {
+                            return Err(Error::DuplicateKey(raw_key).into())
+                        }
+                    }
                 }
             }
+
             _ => match self.unknown.entry(raw_key) {
                 Entry::Vacant(empty_key) => {
                     empty_key.insert(raw_value);