Support t3 addresses

src/note_selection/builder.rs

@@ -164,8 +164,8 @@ pub fn build_tx(
     for output in plan.outputs.iter() {
         let value = Amount::from_u64(output.amount).unwrap();
         match &output.destination {
-            Destination::Transparent(addr) => {
-                let transparent_address = TransparentAddress::PublicKey(*addr);
+            Destination::Transparent(_addr) => {
+                let transparent_address = output.destination.transparent();
                 builder.add_transparent_output(&transparent_address, value)?;
             }
             Destination::Sapling(addr) => {

src/note_selection/types.rs

@@ -57,16 +57,46 @@ pub enum Source {
 #[derive(Clone, Copy, Serialize, Deserialize, Debug)]
 #[serde_as]
 pub enum Destination {
-    Transparent(#[serde(with = "SerHex::<Strict>")] [u8; 20]), // MD5
+    Transparent(#[serde(with = "SerHex::<Strict>")] [u8; 21]), // t1/t3 + Hash
     Sapling(#[serde(with = "SerHex::<Strict>")] [u8; 43]),     // Diversifier + Jubjub Point
     Orchard(#[serde(with = "SerHex::<Strict>")] [u8; 43]),     // Diviersifer + Pallas Point
 }
 
 impl Destination {
-    pub fn address(&self, network: &Network) -> String {
+    pub fn from_transparent(ta: &TransparentAddress) -> Self {
+        let mut d = [0u8; 21];
+        match ta {
+            TransparentAddress::PublicKey(data) => {
+                d[0] = 0;
+                d[1..21].copy_from_slice(&*data);
+            }
+            TransparentAddress::Script(data) => {
+                d[0] = 1;
+                d[1..21].copy_from_slice(&*data);
+            }
+        }
+        Destination::Transparent(d)
+    }
+
+    pub fn transparent(&self) -> TransparentAddress {
         match self {
             Destination::Transparent(data) => {
-                let ta = TransparentAddress::PublicKey(data.clone());
+                let hash: [u8; 20] = data[1..21].try_into().unwrap();
+                let ta = if data[0] == 0 {
+                    TransparentAddress::PublicKey(hash)
+                } else {
+                    TransparentAddress::Script(hash)
+                };
+                ta
+            }
+            _ => unreachable!(),
+        }
+    }
+
+    pub fn address(&self, network: &Network) -> String {
+        match self {
+            Destination::Transparent(_data) => {
+                let ta = self.transparent();
                 ta.encode(network)
             }
             Destination::Sapling(data) => {

src/note_selection/ua.rs

@@ -10,12 +10,12 @@ pub fn decode(network: &Network, address: &str) -> anyhow::Result<[Option<Destin
     if let Ok(data) = decode_payment_address(network.hrp_sapling_payment_address(), address) {
         let destination = Destination::Sapling(data.to_bytes());
         destinations[Pool::Sapling as usize] = Some(destination);
-    } else if let Ok(Some(TransparentAddress::PublicKey(data))) = decode_transparent_address(
+    } else if let Ok(Some(ta)) = decode_transparent_address(
         &network.b58_pubkey_address_prefix(),
         &network.b58_script_address_prefix(),
         address,
     ) {
-        let destination = Destination::Transparent(data);
+        let destination = Destination::from_transparent(&ta);
         destinations[Pool::Transparent as usize] = Some(destination);
     } else if let Ok(address) = ZcashAddress::try_from_encoded(address) {
         // ZcashAddress only supports Zcash
@@ -37,16 +37,22 @@ pub fn decode(network: &Network, address: &str) -> anyhow::Result<[Option<Destin
                             destinations[Pool::Sapling as usize] = Some(destination);
                         }
                         Receiver::P2pkh(data) => {
-                            let destination = Destination::Transparent(data);
+                            let destination =
+                                Destination::from_transparent(&TransparentAddress::PublicKey(data));
+                            destinations[Pool::Transparent as usize] = Some(destination);
+                        }
+                        Receiver::P2sh(data) => {
+                            let destination =
+                                Destination::from_transparent(&TransparentAddress::Script(data));
                             destinations[Pool::Transparent as usize] = Some(destination);
                         }
-                        Receiver::P2sh(_) => {}
                         Receiver::Unknown { .. } => {}
                     }
                 }
             }
             AddressKind::P2pkh(data) => {
-                let destination = Destination::Transparent(data);
+                let destination =
+                    Destination::from_transparent(&TransparentAddress::PublicKey(data));
                 destinations[Pool::Transparent as usize] = Some(destination);
             }
             AddressKind::P2sh(_) => {}