global: snapshot

crates/brk_structs/src/structs/addressbytes.rs

@@ -59,6 +59,12 @@ impl AddressBytes {
     }
 }
 
+impl From<&Address> for AddressBytes {
+    fn from(value: &Address) -> Self {
+        Self::try_from((&value.script_pubkey(), OutputType::from(value))).unwrap()
+    }
+}
+
 impl TryFrom<(&ScriptBuf, OutputType)> for AddressBytes {
     type Error = Error;
     fn try_from(tuple: (&ScriptBuf, OutputType)) -> Result<Self, Self::Error> {

crates/brk_structs/src/structs/addressbyteshash.rs

@@ -1,3 +1,4 @@
+use bitcoin::Address;
 use byteview::ByteView;
 use derive_deref::Deref;
 use zerocopy::{FromBytes, IntoBytes};
@@ -21,6 +22,12 @@ use super::{AddressBytes, OutputType};
 )]
 pub struct AddressBytesHash([u8; 8]);
 
+impl From<&Address> for AddressBytesHash {
+    fn from(value: &Address) -> Self {
+        Self::from((&AddressBytes::from(value), OutputType::from(value)))
+    }
+}
+
 impl From<(&AddressBytes, OutputType)> for AddressBytesHash {
     fn from((address_bytes, outputtype): (&AddressBytes, OutputType)) -> Self {
         let mut slice = rapidhash::v3::rapidhash_v3(address_bytes.as_slice()).to_le_bytes();

crates/brk_structs/src/structs/outputtype.rs

@@ -1,4 +1,5 @@
-use bitcoin::{ScriptBuf, opcodes::all::OP_PUSHBYTES_2};
+use bitcoin::{Address, AddressType, ScriptBuf, opcodes::all::OP_PUSHBYTES_2};
+use brk_error::Error;
 use serde::Serialize;
 use zerocopy_derive::{FromBytes, Immutable, IntoBytes, KnownLayout};
 
@@ -380,3 +381,38 @@ impl From<&ScriptBuf> for OutputType {
         }
     }
 }
+
+impl From<&Address> for OutputType {
+    fn from(value: &Address) -> Self {
+        Self::from(&value.script_pubkey())
+    }
+}
+
+impl From<AddressType> for OutputType {
+    fn from(value: AddressType) -> Self {
+        match value {
+            AddressType::P2a => Self::P2A,
+            AddressType::P2pkh => Self::P2PKH,
+            AddressType::P2sh => Self::P2SH,
+            AddressType::P2tr => Self::P2TR,
+            AddressType::P2wpkh => Self::P2WPKH,
+            AddressType::P2wsh => Self::P2WSH,
+            _ => unreachable!(),
+        }
+    }
+}
+
+impl TryFrom<OutputType> for AddressType {
+    type Error = Error;
+    fn try_from(value: OutputType) -> Result<Self, Self::Error> {
+        Ok(match value {
+            OutputType::P2A => Self::P2a,
+            OutputType::P2PKH => Self::P2pkh,
+            OutputType::P2SH => Self::P2sh,
+            OutputType::P2TR => Self::P2tr,
+            OutputType::P2WPKH => Self::P2wpkh,
+            OutputType::P2WSH => Self::P2wsh,
+            _ => return Err(Error::Str("Bad output format")),
+        })
+    }
+}