psbt: encode using Base64 instead of hex

psbt/Cargo.toml

@@ -23,6 +23,7 @@ bitcoin_hd = { workspace = true }
 bitcoin_onchain = { workspace = true }
 descriptors = { workspace = true, optional = true }
 miniscript_crate = { workspace = true, optional = true }
+base64 = "0.21.4"
 serde_crate = { package = "serde", version = "1", optional = true }
 serde_with = { version = "2.3", features = ["hex"], optional = true }
 

psbt/src/global.rs

@@ -13,7 +13,7 @@ use std::collections::BTreeMap;
 use std::fmt::{Display, Formatter};
 use std::str::FromStr;
 
-use amplify::hex::{FromHex, ToHex};
+use base64::Engine;
 use bitcoin::util::bip32::{ExtendedPubKey, KeySource};
 use bitcoin::{consensus, Transaction, Txid};
 use bitcoin_blockchain::locks::LockTime;
@@ -295,17 +295,34 @@ impl Deserialize for Psbt {
 
 impl Display for Psbt {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        f.write_str(&self.serialize().to_hex())
+        let engine = base64::engine::GeneralPurpose::new(
+            &base64::alphabet::STANDARD,
+            base64::engine::GeneralPurposeConfig::new(),
+        );
+        f.write_str(&engine.encode(self.serialize()))
     }
 }
 
+#[derive(Debug, Display, Error, From)]
+#[display(inner)]
+pub enum PsbtParseError {
+    #[from]
+    Data(consensus::encode::Error),
+
+    #[from]
+    Base64(base64::DecodeError),
+}
+
 impl FromStr for Psbt {
-    type Err = consensus::encode::Error;
+    type Err = PsbtParseError;
 
     fn from_str(s: &str) -> Result<Self, Self::Err> {
-        Psbt::deserialize(
-            &Vec::<u8>::from_hex(s).map_err(|_| Self::Err::ParseFailed("invalid hex encoding"))?,
-        )
+        let engine = base64::engine::GeneralPurpose::new(
+            &base64::alphabet::STANDARD,
+            base64::engine::GeneralPurposeConfig::new(),
+        );
+        let bytes = engine.decode(s)?;
+        Psbt::deserialize(&bytes).map_err(PsbtParseError::from)
     }
 }
 

psbt/src/lib.rs

@@ -49,9 +49,9 @@ mod proprietary;
 pub mod sign;
 
 pub use bitcoin::psbt::raw::ProprietaryKey;
-pub use bitcoin::psbt::{raw, serialize, Error, PsbtParseError, PsbtSighashType};
+pub use bitcoin::psbt::{raw, serialize, Error, PsbtSighashType};
 pub use errors::{FeeError, InputMatchError, TxError, TxinError};
-pub use global::Psbt;
+pub use global::{Psbt, PsbtParseError};
 pub use input::Input;
 pub use output::Output;
 pub(crate) mod v0 {

src/bin/btc-cold.rs

@@ -749,7 +749,7 @@ impl Args {
             stdout().flush()?;
             let stdin = stdin();
             let psbt64 = stdin.lock().lines().next().expect("no PSBT data")?;
-            Psbt::from_str(psbt64.trim()).map_err(Error::psbt_from_consensus)?
+            Psbt::from_str(psbt64.trim())?
         };
         println!("\n{}", serde_yaml::to_string(&psbt)?);
         Ok(())
@@ -930,6 +930,9 @@ pub enum Error {
     #[from]
     PsbtEncoding(psbt::Error),
 
+    #[from]
+    PsbtParse(PsbtParseError),
+
     #[from]
     Miniscript(miniscript::Error),
 
@@ -945,9 +948,6 @@ pub enum Error {
     #[from]
     Yaml(serde_yaml::Error),
 
-    #[from]
-    PsbtBase58(PsbtParseError),
-
     #[from]
     PsbtConstruction(construct::Error),
 
@@ -984,10 +984,11 @@ pub enum Error {
 
 impl Error {
     pub fn psbt_from_consensus(e: consensus::encode::Error) -> Error {
-        let consensus::encode::Error::Psbt(e) = e else {
-            unreachable!()
-        };
-        Error::PsbtEncoding(e)
+        match e {
+            consensus::encode::Error::Psbt(e) => Error::PsbtEncoding(e),
+            consensus::encode::Error::Io(e) => e.into(),
+            err => unreachable!("{err:#?}"),
+        }
     }
 }