Update to bitcoin 0.30

Also performs a general update with a variety of upgraded Substrate depends.

substrate/client/Cargo.toml

@@ -23,7 +23,7 @@ serai-runtime = { path = "../runtime", version = "0.1" }
 sp-core = { git = "https://github.com/serai-dex/substrate" }
 subxt = { version = "0.27", default-features = false, features = ["jsonrpsee-ws"], optional = true }
 
-bitcoin = { version = "0.29", optional = true }
+bitcoin = { version = "0.30", optional = true }
 
 ciphersuite = { path = "../../crypto/ciphersuite", version = "0.3", optional = true }
 monero-serai = { path = "../../coins/monero", version = "0.1.4-alpha", optional = true }

substrate/client/src/coins/bitcoin.rs

@@ -6,16 +6,40 @@ use bitcoin::{
   hashes::{Hash as HashTrait, hash160::Hash},
   PubkeyHash, ScriptHash,
   network::constants::Network,
-  util::address::{Error, WitnessVersion, Payload, Address as BAddress},
+  address::{
+    Error, WitnessVersion, Payload, WitnessProgram, NetworkChecked, Address as BAddressGeneric,
+  },
 };
 
-#[derive(Clone, PartialEq, Eq, Debug)]
+type BAddress = BAddressGeneric<NetworkChecked>;
+
+#[derive(Clone, Eq, Debug)]
 pub struct Address(pub BAddress);
 
+impl PartialEq for Address {
+  fn eq(&self, other: &Self) -> bool {
+    self.0.payload == other.0.payload
+  }
+}
+
 impl FromStr for Address {
   type Err = Error;
   fn from_str(str: &str) -> Result<Address, Error> {
-    BAddress::from_str(str).map(Address)
+    let mut original_address = BAddressGeneric::from_str(str)?;
+    // Standardize the network
+    original_address.network = Network::Bitcoin;
+    let address = original_address
+      .clone()
+      .require_network(Network::Bitcoin)
+      .expect("network wasn't mainnet despite overriding network");
+
+    // Also check this isn't caching the string internally
+    if BAddressGeneric::from_str(&address.to_string())? != original_address {
+      // TODO: Make this an error?
+      panic!("Address::from_str(address.to_string()) != address for Bitcoin");
+    }
+
+    Ok(Address(address))
   }
 }
 
@@ -38,26 +62,26 @@ enum EncodedAddress {
 impl TryFrom<Vec<u8>> for Address {
   type Error = ();
   fn try_from(data: Vec<u8>) -> Result<Address, ()> {
-    Ok(Address(BAddress {
-      network: Network::Bitcoin,
-      payload: match EncodedAddress::decode(&mut data.as_ref()).map_err(|_| ())? {
+    Ok(Address(BAddress::new(
+      Network::Bitcoin,
+      match EncodedAddress::decode(&mut data.as_ref()).map_err(|_| ())? {
         EncodedAddress::P2PKH(hash) => {
-          Payload::PubkeyHash(PubkeyHash::from_hash(Hash::from_inner(hash)))
+          Payload::PubkeyHash(PubkeyHash::from_raw_hash(Hash::from_byte_array(hash)))
         }
         EncodedAddress::P2SH(hash) => {
-          Payload::ScriptHash(ScriptHash::from_hash(Hash::from_inner(hash)))
+          Payload::ScriptHash(ScriptHash::from_raw_hash(Hash::from_byte_array(hash)))
         }
         EncodedAddress::P2WPKH(hash) => {
-          Payload::WitnessProgram { version: WitnessVersion::V0, program: hash.to_vec() }
+          Payload::WitnessProgram(WitnessProgram::new(WitnessVersion::V0, hash).unwrap())
         }
         EncodedAddress::P2WSH(hash) => {
-          Payload::WitnessProgram { version: WitnessVersion::V0, program: hash.to_vec() }
+          Payload::WitnessProgram(WitnessProgram::new(WitnessVersion::V0, hash).unwrap())
         }
         EncodedAddress::P2TR(key) => {
-          Payload::WitnessProgram { version: WitnessVersion::V1, program: key.to_vec() }
+          Payload::WitnessProgram(WitnessProgram::new(WitnessVersion::V1, key).unwrap())
         }
       },
-    }))
+    )))
   }
 }
 
@@ -67,20 +91,29 @@ impl TryInto<Vec<u8>> for Address {
   fn try_into(self) -> Result<Vec<u8>, ()> {
     Ok(
       (match self.0.payload {
-        Payload::PubkeyHash(hash) => EncodedAddress::P2PKH(hash.as_hash().into_inner()),
-        Payload::ScriptHash(hash) => EncodedAddress::P2SH(hash.as_hash().into_inner()),
-        Payload::WitnessProgram { version: WitnessVersion::V0, program } => {
-          if program.len() == 20 {
-            EncodedAddress::P2WPKH(program.try_into().map_err(|_| ())?)
-          } else if program.len() == 32 {
-            EncodedAddress::P2WSH(program.try_into().map_err(|_| ())?)
-          } else {
-            Err(())?
+        Payload::PubkeyHash(hash) => EncodedAddress::P2PKH(*hash.as_raw_hash().as_byte_array()),
+        Payload::ScriptHash(hash) => EncodedAddress::P2SH(*hash.as_raw_hash().as_byte_array()),
+        Payload::WitnessProgram(program) => match program.version() {
+          WitnessVersion::V0 => {
+            let program = program.program();
+            if program.len() == 20 {
+              let mut buf = [0; 20];
+              buf.copy_from_slice(program.as_ref());
+              EncodedAddress::P2WPKH(buf)
+            } else if program.len() == 32 {
+              let mut buf = [0; 32];
+              buf.copy_from_slice(program.as_ref());
+              EncodedAddress::P2WSH(buf)
+            } else {
+              Err(())?
+            }
           }
-        }
-        Payload::WitnessProgram { version: WitnessVersion::V1, program } => {
-          EncodedAddress::P2TR(program.try_into().map_err(|_| ())?)
-        }
+          WitnessVersion::V1 => {
+            let program_ref: &[u8] = program.program().as_ref();
+            EncodedAddress::P2TR(program_ref.try_into().map_err(|_| ())?)
+          }
+          _ => Err(())?,
+        },
         _ => Err(())?,
       })
       .encode(),

substrate/client/src/coins/monero.rs

@@ -68,8 +68,8 @@ impl TryFrom<Vec<u8>> for Address {
           }
         },
       ),
-      Ed25519::read_G(&mut addr.spend.as_ref()).map_err(|_| ())?.0,
-      Ed25519::read_G(&mut addr.view.as_ref()).map_err(|_| ())?.0,
+      Ed25519::read_G::<&[u8]>(&mut addr.spend.as_ref()).map_err(|_| ())?.0,
+      Ed25519::read_G::<&[u8]>(&mut addr.view.as_ref()).map_err(|_| ())?.0,
     )))
   }
 }