Add to and from base64 string o pset

via standard trait Display and FromStr like it's done in rust-bitcoin PSBT.

Reuse rust-bitcoin base64 re-exported

Cargo.toml

@@ -19,6 +19,7 @@ json-contract = [ "serde_json" ]
     "secp256k1-zkp/serde",
     "actual-serde"
 ]
+base64 = ["bitcoin/base64"]
 
 [dependencies]
 bitcoin = "0.30.0"
@@ -37,7 +38,6 @@ serde_test = "1.0.19"
 serde_json = "1.0"
 serde_cbor = "0.8"   # older than latest version to support 1.41.1
 bincode = "1.3"
-base64 = "0.13.0"
 
 [[example]]
 name = "pset_blind_coinjoin"

elementsd-tests/Cargo.toml

@@ -7,9 +7,8 @@ edition = "2018"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-base64 = "0.13.0"
 bitcoin = "0.30.0"
-elements = {path = "../"}
+elements = {path = "../", features = ["base64"]}
 elementsd = "0.8.0"
 rand = "0.8"
 

elementsd-tests/src/pset.rs

@@ -8,7 +8,7 @@ use crate::{setup, Call};
 
 use bitcoin::{self, Address, Amount};
 use elements::hex::ToHex;
-use elements::encode::{deserialize, serialize};
+use elements::encode::serialize;
 use elements::hashes::Hash;
 use elements::pset::PartiallySignedTransaction;
 use elements::{AssetId, ContractHash};
@@ -131,15 +131,16 @@ fn tx_pegin() {
 }
 
 fn rtt(base64: &str) -> String {
-    base64::encode(serialize(&psbt_from_base64(&base64)))
+    let pset: PartiallySignedTransaction = base64.parse().unwrap();
+    pset.to_string()
 }
 
 fn psbt_rtt(elementsd: &ElementsD, base64: &str) {
     let a = elementsd.decode_psbt(&base64).unwrap();
 
-    let b_psbt = psbt_from_base64(&base64);
+    let b_psbt: PartiallySignedTransaction = base64.parse().unwrap();
     let mut b_bytes = serialize(&b_psbt);
-    let b_base64 = base64::encode(&b_bytes);
+    let b_base64 = bitcoin::base64::encode(&b_bytes);
     let b = elementsd.decode_psbt(&b_base64).unwrap();
 
     assert_eq!(a, b);
@@ -151,16 +152,10 @@ fn psbt_rtt(elementsd: &ElementsD, base64: &str) {
         // ensuring decode prints all data inside psbt, randomly changing a byte,
         // if the results is still decodable it should not be equal to initial value
         b_bytes[i] = b_bytes[i].wrapping_add(1);
-        let base64 = base64::encode(&b_bytes);
+        let base64 = bitcoin::base64::encode(&b_bytes);
         if let Some(decoded) = elementsd.decode_psbt(&base64) {
             assert_ne!(a, decoded, "{} with changed byte {}", b_bytes.to_hex(), i);
         }
         b_bytes[i] = b_bytes[i].wrapping_sub(1);
     }
 }
-
-fn psbt_from_base64(base64: &str) -> PartiallySignedTransaction {
-    let bytes = base64::decode(&base64).unwrap();
-    deserialize(&bytes).unwrap()
-}
-

src/pset/mod.rs

@@ -30,6 +30,9 @@ mod map;
 pub mod raw;
 pub mod serialize;
 
+#[cfg(feature = "base64")]
+mod str;
+
 use crate::blind::{BlindAssetProofs, BlindValueProofs};
 use crate::confidential;
 use crate::encode::{self, Decodable, Encodable};

src/pset/str.rs

@@ -0,0 +1,43 @@
+use super::PartiallySignedTransaction;
+
+#[derive(Debug)]
+pub enum Error {
+    Base64(bitcoin::base64::DecodeError),
+    Deserialize(crate::encode::Error)
+}
+
+impl core::fmt::Display for Error {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Error::Base64(_) => write!(f, "Base64 error"),
+            Error::Deserialize(_) => write!(f, "Deserialize error"),
+        }
+    }
+}
+
+impl std::error::Error for Error {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        match self {
+            Error::Base64(e) => Some(e),
+            Error::Deserialize(e) => Some(e),
+        }
+    }
+
+}
+
+impl std::str::FromStr for PartiallySignedTransaction {
+    type Err=Error;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        let bytes = bitcoin::base64::decode(s).map_err(|e| Error::Base64(e))?;
+        Ok(crate::encode::deserialize(&bytes).map_err(|e| Error::Deserialize(e))?)
+    }
+}
+
+impl std::fmt::Display for PartiallySignedTransaction {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let bytes = crate::encode::serialize(self);
+        let base64 = bitcoin::base64::encode(&bytes);
+        write!(f, "{}", base64)
+    }
+}