diff --git a/rust/bt-bass/src/client.rs b/rust/bt-bass/src/client.rs
index f7b3f5b..7519501 100644
--- a/rust/bt-bass/src/client.rs
+++ b/rust/bt-bass/src/client.rs
@@ -5,11 +5,11 @@
 pub mod error;
 pub mod event;
 
-use std::collections::{HashMap, HashSet};
+use std::collections::HashMap;
 use std::sync::Arc;
 
-use futures::Future;
 use futures::stream::{BoxStream, FusedStream, SelectAll, Stream, StreamExt};
+use futures::Future;
 use log::warn;
 use parking_lot::Mutex;
 
@@ -26,22 +26,6 @@
 
 const READ_CHARACTERISTIC_BUFFER_SIZE: usize = 255;
 
-/// Index into the vector of BIG subgroups. Valid value range is [0 to len of
-/// BIG vector).
-pub type SubgroupIndex = u8;
-
-/// Synchronization information for BIG groups to tell which
-/// BISes it should sync to.
-pub type BigToBisSync = HashSet<(SubgroupIndex, BisIndex)>;
-
-pub fn big_to_bis_sync_indices(info: &BigToBisSync) -> HashMap<SubgroupIndex, Vec<BisIndex>> {
-    let mut sync_map = HashMap::new();
-    for (ith_group, bis_index) in info.iter() {
-        sync_map.entry(*ith_group).or_insert(Vec::new()).push(*bis_index);
-    }
-    sync_map
-}
-
 /// Keeps track of Source_ID and Broadcast_ID that are associated together.
 /// Source_ID is assigned by the BASS server to a Broadcast Receive State
 /// characteristic. If the remote peer with the BASS server autonomously
@@ -321,7 +305,7 @@
         broadcast_id: BroadcastId,
         pa_sync: PaSync,
         pa_interval: Option<PaInterval>,
-        bis_sync: Option<BigToBisSync>,
+        bis_sync: Option<HashMap<SubgroupIndex, BisSync>>,
         metadata_map: Option<HashMap<SubgroupIndex, Vec<Metadata>>>,
     ) -> Result<(), Error> {
         let op = {
@@ -330,12 +314,10 @@
                 .ok_or(Error::UnknownBroadcastSource(broadcast_id))?;
 
             // Update BIS_Sync param for BIGs if applicable.
-            if let Some(m) = bis_sync {
-                let sync_map = big_to_bis_sync_indices(&m);
-
+            if let Some(sync_map) = bis_sync {
                 for (big_index, group) in state.subgroups.iter_mut().enumerate() {
-                    if let Some(bis_indices) = sync_map.get(&(big_index as u8)) {
-                        group.bis_sync.set_sync(bis_indices).map_err(|e| Error::Packet(e))?;
+                    if let Some(bis_sync) = sync_map.get(&(big_index as u8)) {
+                        group.bis_sync = bis_sync.clone();
                     }
                 }
             }
@@ -420,15 +402,15 @@
 
     use assert_matches::assert_matches;
     use futures::executor::block_on;
-    use futures::{FutureExt, pin_mut};
+    use futures::{pin_mut, FutureExt};
 
-    use bt_common::Uuid;
     use bt_common::core::AdvertisingSetId;
-    use bt_gatt::Characteristic;
+    use bt_common::Uuid;
     use bt_gatt::test_utils::*;
     use bt_gatt::types::{
         AttributePermissions, CharacteristicProperties, CharacteristicProperty, Handle,
     };
+    use bt_gatt::Characteristic;
 
     const RECEIVE_STATE_1_HANDLE: Handle = Handle(1);
     const RECEIVE_STATE_2_HANDLE: Handle = Handle(2);
@@ -833,7 +815,7 @@
             vec![
                 0x03, 0x11, 0x00,                    // opcode, source id, pa sync
                 0xFF, 0xFF, 0x02,                    // pa sync, pa interval, num of subgroups
-                0x17, 0x00, 0x00, 0x00,              // bis sync (0th subgroup)
+                0x15, 0x00, 0x00, 0x00,              // bis sync (0th subgroup)
                 0x02, 0x01, 0x09,                    // metadata len, metadata
                 0xFF, 0xFF, 0xFF, 0xFF,              // bis sync (1th subgroup)
                 0x05, 0x04, 0x04, 0x65, 0x6E, 0x67,  // metadata len, metadata
@@ -845,7 +827,7 @@
             BroadcastId::try_from(0x11).unwrap(),
             PaSync::DoNotSync,
             None,
-            Some(HashSet::from([(0, 1), (0, 2), (0, 3), (0, 5)])),
+            Some(HashMap::from([(0, BisSync::sync(vec![1, 3, 5]).unwrap())])),
             Some(HashMap::from([
                 (0, vec![Metadata::BroadcastAudioImmediateRenderingFlag]),
                 (1, vec![Metadata::Language("eng".to_string())]),
diff --git a/rust/bt-bass/src/types.rs b/rust/bt-bass/src/types.rs
index 22baa25..3f8e2d3 100644
--- a/rust/bt-bass/src/types.rs
+++ b/rust/bt-bass/src/types.rs
@@ -7,7 +7,8 @@
 use bt_common::core::{AddressType, AdvertisingSetId, PaInterval};
 use bt_common::generic_audio::metadata_ltv::*;
 use bt_common::packet_encoding::{Decodable, Encodable, Error as PacketError};
-use bt_common::{Uuid, decodable_enum};
+use bt_common::{decodable_enum, Uuid};
+use std::str::FromStr;
 
 pub const ADDRESS_BYTE_SIZE: usize = 6;
 const NUM_SUBGROUPS_BYTE_SIZE: usize = 1;
@@ -21,6 +22,10 @@
 
 pub type SourceId = u8;
 
+/// Index into the vector of BIG subgroups. Valid value range is [0 to len of
+/// BIG vector).
+pub type SubgroupIndex = u8;
+
 /// BIS index value of a particular BIS. Valid value range is [1 to len of BIS]
 pub type BisIndex = u8;
 
@@ -500,29 +505,46 @@
     }
 }
 
+impl FromStr for PaSync {
+    type Err = PacketError;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        match s {
+            "PaSyncOff" => Ok(PaSync::DoNotSync),
+            "PaSyncPast" => Ok(PaSync::SyncPastAvailable),
+            "PaSyncNoPast" => Ok(PaSync::SyncPastUnavailable),
+            _ => Err(PacketError::InvalidParameter(format!("invalid pa_sync: {s}"))),
+        }
+    }
+}
+
 /// 4-octet bitfield. Bit 0-30 = BIS_index[1-31]
 /// 0x00000000: 0b0 = Do not synchronize to BIS_index[x]
 /// 0xxxxxxxxx: 0b1 = Synchronize to BIS_index[x]
 /// 0xFFFFFFFF: means No preference if used in BroadcastAudioScanControlPoint,
 ///             Failed to sync if used in ReceiveState.
 #[derive(Clone, Debug, PartialEq)]
-pub struct BisSync(pub u32);
+pub struct BisSync(u32);
 
 impl BisSync {
     const BYTE_SIZE: usize = 4;
     const NO_PREFERENCE: u32 = 0xFFFFFFFF;
 
-    /// Updates whether or not a particular BIS should be set to synchronize or
-    /// not synchronize.
+    /// Creates a new BisSync that doens't synchronzie to any BISes.
+    pub fn no_sync() -> BisSync {
+        BisSync(0)
+    }
+
+    /// Updates the specified BIS index to be synchronized.
+    /// Doesn't touch the synchronize value of other BIS indices.
     ///
     /// # Arguments
     ///
     /// * `bis_index` - BIS index as defined in the spec. Range should be [1,
-    ///   31]
-    /// * `should_sync` - Whether or not to synchronize
-    fn set_sync_for_index(&mut self, bis_index: BisIndex) -> Result<(), PacketError> {
+    ///   31]. The specified BIS index will be set to synchronized (0b1).
+    pub fn synchronize_to_index(&mut self, bis_index: BisIndex) -> Result<(), PacketError> {
         if bis_index < 1 || bis_index > 31 {
-            return Err(PacketError::InvalidParameter(format!("Invalid BIS index ({bis_index})")));
+            return Err(PacketError::OutOfRange);
         }
         let bit_mask = 0b1 << (bis_index - 1);
 
@@ -532,24 +554,18 @@
         Ok(())
     }
 
-    /// Clears previous BIS_Sync params and synchronizes to specified BIS
-    /// indices. If the BIS index list is empty, no preference value is
-    /// used.
+    /// Creates a BisSync value with the specified BIS indices set to be
+    /// synchronized.
     ///
     /// # Arguments
     ///
-    /// * `sync_map` - Map of BIS index to whether or not it should be
-    ///   synchronized
-    pub fn set_sync(&mut self, bis_indices: &Vec<BisIndex>) -> Result<(), PacketError> {
-        if bis_indices.is_empty() {
-            self.0 = Self::NO_PREFERENCE;
-            return Ok(());
-        }
-        self.0 = 0;
+    /// * `bis_indices` - A vector of BIS indices to synchronize to.
+    pub fn sync(bis_indices: Vec<BisIndex>) -> Result<Self, PacketError> {
+        let mut new_sync = Self::no_sync();
         for bis_index in bis_indices {
-            self.set_sync_for_index(*bis_index)?;
+            new_sync.synchronize_to_index(bis_index)?;
         }
-        Ok(())
+        Ok(new_sync)
     }
 }
 
@@ -559,6 +575,12 @@
     }
 }
 
+impl From<BisSync> for u32 {
+    fn from(bis_sync: BisSync) -> u32 {
+        bis_sync.0
+    }
+}
+
 #[derive(Clone, Debug, PartialEq)]
 pub struct BigSubgroup {
     pub(crate) bis_sync: BisSync,
@@ -620,7 +642,7 @@
             return Err(PacketError::BufferTooSmall);
         }
 
-        buf[0..4].copy_from_slice(&self.bis_sync.0.to_le_bytes());
+        buf[0..4].copy_from_slice(&u32::from(self.bis_sync.clone()).to_le_bytes());
         let metadata_len = self
             .metadata
             .iter()
@@ -1049,24 +1071,44 @@
     }
 
     #[test]
-    fn bis_sync() {
-        let mut bis_sync = BisSync::default();
-        assert_eq!(bis_sync, BisSync(BisSync::NO_PREFERENCE));
+    fn bis_sync_sync() {
+        let bis_sync = BisSync::sync(vec![1, 6, 31]).expect("should succeed");
+        assert_eq!(u32::from(bis_sync), 0x40000021);
 
-        bis_sync.set_sync(&vec![1, 6, 31]).expect("should succeed");
-        assert_eq!(bis_sync, BisSync(0x40000021));
-
-        bis_sync.set_sync(&vec![]).expect("should succeed");
-        assert_eq!(bis_sync, BisSync::default());
+        let bis_sync_empty = BisSync::sync(vec![]).expect("should succeed");
+        assert_eq!(u32::from(bis_sync_empty), 0);
     }
 
     #[test]
     fn invalid_bis_sync() {
-        let mut bis_sync = BisSync::default();
+        BisSync::sync(vec![0]).expect_err("should fail");
+        BisSync::sync(vec![32]).expect_err("should fail");
+    }
 
-        bis_sync.set_sync(&vec![0]).expect_err("should fail");
+    #[test]
+    fn synchronize_to_index() {
+        let mut bis_sync = BisSync::no_sync();
+        assert_eq!(u32::from(bis_sync.clone()), 0);
 
-        bis_sync.set_sync(&vec![32]).expect_err("should fail");
+        bis_sync.synchronize_to_index(1).expect("should succeed");
+        assert_eq!(u32::from(bis_sync.clone()), 0x1);
+
+        bis_sync.synchronize_to_index(31).expect("should succeed");
+        assert_eq!(u32::from(bis_sync.clone()), 0x40000001);
+
+        bis_sync.synchronize_to_index(0).expect_err("should fail");
+        bis_sync.synchronize_to_index(32).expect_err("should fail");
+    }
+
+    #[test]
+    fn pa_sync_from_str() {
+        let sync = PaSync::from_str("PaSyncOff").expect("should succeed");
+        assert_eq!(sync, PaSync::DoNotSync);
+        let sync = PaSync::from_str("PaSyncPast").expect("should succeed");
+        assert_eq!(sync, PaSync::SyncPastAvailable);
+        let sync = PaSync::from_str("PaSyncNoPast").expect("should succeed");
+        assert_eq!(sync, PaSync::SyncPastUnavailable);
+        PaSync::from_str("invalid").expect_err("should fail");
     }
 
     #[test]
diff --git a/rust/bt-broadcast-assistant/src/assistant.rs b/rust/bt-broadcast-assistant/src/assistant.rs
index 3fd08cb..b8b50af 100644
--- a/rust/bt-broadcast-assistant/src/assistant.rs
+++ b/rust/bt-broadcast-assistant/src/assistant.rs
@@ -4,6 +4,7 @@
 
 use parking_lot::Mutex;
 use std::collections::HashMap;
+use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::Arc;
 use thiserror::Error;
 
@@ -101,7 +102,7 @@
 pub struct BroadcastAssistant<T: bt_gatt::GattTypes> {
     central: T::Central,
     broadcast_sources: Arc<DiscoveredBroadcastSources>,
-    scan_stream: Option<T::ScanResultStream>,
+    broadcast_source_scan_started: Arc<AtomicBool>,
 }
 
 impl<T: bt_gatt::GattTypes + 'static> BroadcastAssistant<T> {
@@ -109,11 +110,10 @@
     // for broadcast source scanning. Clients must use the `start`
     // method to poll the event stream for scan results.
     pub fn new(central: T::Central) -> Self {
-        let scan_result_stream = central.scan(&Self::scan_filters());
         Self {
             central,
             broadcast_sources: DiscoveredBroadcastSources::new(),
-            scan_stream: Some(scan_result_stream),
+            broadcast_source_scan_started: Arc::new(AtomicBool::new(false)),
         }
     }
 
@@ -130,17 +130,33 @@
     /// poll. Upper layer can call methods on BroadcastAssistant based on the
     /// events it sees.
     pub fn start(&mut self) -> Result<EventStream<T>, Error> {
-        if self.scan_stream.is_none() {
+        if self.is_started() {
             return Err(Error::AlreadyStarted);
         }
-        Ok(EventStream::<T>::new(self.scan_stream.take().unwrap(), self.broadcast_sources.clone()))
+        let scan_result_stream = self.central.scan(&Self::scan_filters());
+        self.broadcast_source_scan_started.store(true, Ordering::Relaxed);
+        Ok(EventStream::<T>::new(
+            scan_result_stream,
+            self.broadcast_sources.clone(),
+            self.broadcast_source_scan_started.clone(),
+        ))
     }
 
-    pub fn scan_for_scan_delegators(&mut self) -> T::ScanResultStream {
+    /// Returns whether or not Broadcast Assistant has started.
+    fn is_started(&self) -> bool {
+        self.broadcast_source_scan_started.load(Ordering::Relaxed)
+    }
+
+    pub fn scan_for_scan_delegators(&mut self) -> Result<T::ScanResultStream, Error> {
+        if self.is_started() {
+            return Err(Error::Generic(format!(
+                "Cannot scan for scan delegators while scanning for broadcast sources"
+            )));
+        }
         // Scan for service data with Broadcast Audio Scan Service UUID to look
         // for Broadcast Sink collocated with the Scan Delegator (see BAP spec v1.0.1
         // Section 3.9.2 for details).
-        self.central.scan(&vec![Filter::HasServiceData(BROADCAST_AUDIO_SCAN_SERVICE).into()])
+        Ok(self.central.scan(&vec![Filter::HasServiceData(BROADCAST_AUDIO_SCAN_SERVICE).into()]))
     }
 
     pub async fn connect_to_scan_delegator(&self, peer_id: PeerId) -> Result<Peer<T>, Error>
@@ -172,17 +188,13 @@
         &self,
         peer_id: PeerId,
         address: [u8; 6],
-        raw_address_type: u8,
-        raw_advertising_sid: u8,
+        address_type: bt_common::core::AddressType,
+        advertising_sid: bt_common::core::AdvertisingSetId,
     ) -> Result<BroadcastSource, Error> {
-        use bt_common::core::{AddressType, AdvertisingSetId};
         let broadcast_source = BroadcastSource {
             address: Some(address),
-            address_type: Some(
-                AddressType::try_from(raw_address_type)
-                    .map_err(|e| Error::Generic(e.to_string()))?,
-            ),
-            advertising_sid: Some(AdvertisingSetId(raw_advertising_sid)),
+            address_type: Some(address_type),
+            advertising_sid: Some(advertising_sid),
             broadcast_id: None,
             pa_interval: None,
             endpoint: None,
@@ -196,27 +208,13 @@
     pub fn force_discover_broadcast_source_metadata(
         &self,
         peer_id: PeerId,
-        raw_metadata: Vec<Vec<u8>>,
+        big_metadata: Vec<Vec<bt_common::generic_audio::metadata_ltv::Metadata>>,
     ) -> Result<BroadcastSource, Error> {
         use bt_bap::types::{BroadcastAudioSourceEndpoint, BroadcastIsochronousGroup};
-        use bt_common::core::ltv::LtValue;
         use bt_common::core::CodecId;
-        use bt_common::generic_audio::metadata_ltv::Metadata;
 
         let mut big = Vec::new();
-        for bytes in raw_metadata {
-            let metadata = {
-                if bytes.len() > 0 {
-                    let (decoded_metadata, consumed_len) = Metadata::decode_all(bytes.as_slice());
-                    if consumed_len != bytes.len() {
-                        return Err(Error::Generic("Metadata length is not valid".to_string()));
-                    }
-                    decoded_metadata.into_iter().filter_map(Result::ok).collect()
-                } else {
-                    vec![]
-                }
-            };
-
+        for metadata in big_metadata {
             let group = BroadcastIsochronousGroup {
                 codec_id: CodecId::Assigned(bt_common::core::CodingFormat::ALawLog), // mock.
                 codec_specific_configs: vec![],
@@ -261,6 +259,7 @@
 
     use bt_bap::types::*;
     use bt_common::core::{AddressType, AdvertisingSetId};
+    use bt_common::generic_audio::metadata_ltv::Metadata;
     use bt_gatt::test_utils::{FakeCentral, FakeClient, FakeTypes};
 
     use crate::assistant::peer::tests::fake_bass_service;
@@ -324,10 +323,16 @@
     #[test]
     fn start_stream() {
         let mut assistant = BroadcastAssistant::<FakeTypes>::new(FakeCentral::new());
-        let _ = assistant.start().expect("can start stream");
+        let stream = assistant.start().expect("can start stream");
 
         // Stream can only be started once.
+        assert!(assistant.is_started());
         assert!(assistant.start().is_err());
+
+        // After the stream is dropped, it can be started again.
+        drop(stream);
+        assert!(!assistant.is_started());
+        assert!(assistant.start().is_ok());
     }
 
     #[test]
@@ -349,4 +354,34 @@
         };
         let _ = res.expect("should be ok");
     }
+
+    #[test]
+    fn force_discover_broadcast_source_test() {
+        let assistant = BroadcastAssistant::<FakeTypes>::new(FakeCentral::new());
+        let peer_id = PeerId(1);
+        let address = [1, 2, 3, 4, 5, 6];
+        let address_type = AddressType::Public;
+        let sid = AdvertisingSetId(1);
+
+        let source =
+            assistant.force_discover_broadcast_source(peer_id, address, address_type, sid).unwrap();
+
+        assert_eq!(source.address, Some(address));
+        assert_eq!(source.address_type, Some(address_type));
+        assert_eq!(source.advertising_sid, Some(sid));
+    }
+
+    #[test]
+    fn force_discover_broadcast_source_metadata_test() {
+        let assistant = BroadcastAssistant::<FakeTypes>::new(FakeCentral::new());
+        let peer_id = PeerId(1);
+        let metadata = vec![vec![Metadata::BroadcastAudioImmediateRenderingFlag]];
+
+        let source =
+            assistant.force_discover_broadcast_source_metadata(peer_id, metadata.clone()).unwrap();
+
+        let endpoint = source.endpoint.unwrap();
+        assert_eq!(endpoint.big.len(), 1);
+        assert_eq!(endpoint.big[0].metadata, metadata[0]);
+    }
 }
diff --git a/rust/bt-broadcast-assistant/src/assistant/event.rs b/rust/bt-broadcast-assistant/src/assistant/event.rs
index 7290e47..741c04c 100644
--- a/rust/bt-broadcast-assistant/src/assistant/event.rs
+++ b/rust/bt-broadcast-assistant/src/assistant/event.rs
@@ -4,18 +4,20 @@
 
 use core::pin::Pin;
 use futures::stream::{FusedStream, Stream, StreamExt};
+use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::Arc;
 use std::task::Poll;
 
 use bt_bap::types::{BroadcastAudioSourceEndpoint, BroadcastId};
-use bt_common::PeerId;
+use bt_common::core::AdvertisingSetId;
 use bt_common::packet_encoding::Decodable;
 use bt_common::packet_encoding::Error as PacketError;
+use bt_common::PeerId;
 use bt_gatt::central::{AdvertisingDatum, ScanResult};
 
 use crate::assistant::{
-    BASIC_AUDIO_ANNOUNCEMENT_SERVICE, BROADCAST_AUDIO_ANNOUNCEMENT_SERVICE,
-    DiscoveredBroadcastSources, Error,
+    DiscoveredBroadcastSources, Error, BASIC_AUDIO_ANNOUNCEMENT_SERVICE,
+    BROADCAST_AUDIO_ANNOUNCEMENT_SERVICE,
 };
 use crate::types::BroadcastSource;
 
@@ -33,17 +35,20 @@
     terminated: bool,
 
     broadcast_sources: Arc<DiscoveredBroadcastSources>,
+    broadcast_source_scan_started: Arc<AtomicBool>,
 }
 
 impl<T: bt_gatt::GattTypes> EventStream<T> {
     pub(crate) fn new(
         scan_result_stream: T::ScanResultStream,
         broadcast_sources: Arc<DiscoveredBroadcastSources>,
+        broadcast_source_scan_started: Arc<AtomicBool>,
     ) -> Self {
         Self {
             scan_result_stream: Box::pin(scan_result_stream),
             terminated: false,
             broadcast_sources,
+            broadcast_source_scan_started,
         }
     }
 
@@ -67,10 +72,19 @@
                 source.get_or_insert(BroadcastSource::default()).with_endpoint(base);
             }
         }
+        if let Some(src) = &mut source {
+            src.advertising_sid = Some(AdvertisingSetId(scan_result.advertising_sid));
+        }
         Ok(source)
     }
 }
 
+impl<T: bt_gatt::GattTypes> Drop for EventStream<T> {
+    fn drop(&mut self) {
+        self.broadcast_source_scan_started.store(false, Ordering::Relaxed);
+    }
+}
+
 impl<T: bt_gatt::GattTypes> FusedStream for EventStream<T> {
     fn is_terminated(&self) -> bool {
         self.terminated
@@ -122,6 +136,7 @@
             }
             None | Some(Err(_)) => {
                 self.terminated = true;
+                self.broadcast_source_scan_started.store(false, Ordering::Relaxed);
                 Poll::Ready(Some(Err(Error::CentralScanTerminated)))
             }
         }
@@ -143,9 +158,14 @@
     fn setup_stream() -> (EventStream<FakeTypes>, ScannedResultStream) {
         let fake_scan_result_stream = ScannedResultStream::new();
         let broadcast_sources = DiscoveredBroadcastSources::new();
+        let broadcast_source_scan_started = Arc::new(AtomicBool::new(false));
 
         (
-            EventStream::<FakeTypes>::new(fake_scan_result_stream.clone(), broadcast_sources),
+            EventStream::<FakeTypes>::new(
+                fake_scan_result_stream.clone(),
+                broadcast_sources,
+                broadcast_source_scan_started,
+            ),
             fake_scan_result_stream,
         )
     }
@@ -210,7 +230,7 @@
                 BASIC_AUDIO_ANNOUNCEMENT_SERVICE,
                 base_data.clone(),
             )],
-            advertising_sid: 0,
+            advertising_sid: 1,
         }));
 
         // Expect the stream to send out broadcast source found event since information
@@ -218,8 +238,9 @@
         let Poll::Ready(Some(Ok(event))) = stream.poll_next_unpin(&mut noop_cx) else {
             panic!("should have received event");
         };
-        assert_matches!(event, Event::FoundBroadcastSource{peer, ..} => {
-            assert_eq!(peer, broadcast_source_pid)
+        assert_matches!(event, Event::FoundBroadcastSource{peer, source} => {
+            assert_eq!(peer, broadcast_source_pid);
+            assert_eq!(source.advertising_sid, Some(AdvertisingSetId(1)));
         });
 
         assert!(stream.poll_next_unpin(&mut noop_cx).is_pending());
@@ -233,7 +254,7 @@
                 BASIC_AUDIO_ANNOUNCEMENT_SERVICE,
                 base_data.clone(),
             )],
-            advertising_sid: 0,
+            advertising_sid: 1,
         }));
 
         // Shouldn't have gotten the event again since the information remained the
diff --git a/rust/bt-broadcast-assistant/src/assistant/peer.rs b/rust/bt-broadcast-assistant/src/assistant/peer.rs
index 5c3b5b5..73029d8 100644
--- a/rust/bt-broadcast-assistant/src/assistant/peer.rs
+++ b/rust/bt-broadcast-assistant/src/assistant/peer.rs
@@ -11,15 +11,16 @@
 use bt_bap::types::BroadcastId;
 use bt_bass::client::error::Error as BassClientError;
 use bt_bass::client::event::Event as BassEvent;
-use bt_bass::client::{BigToBisSync, BroadcastAudioScanServiceClient};
+use bt_bass::client::BroadcastAudioScanServiceClient;
 #[cfg(any(test, feature = "debug"))]
 use bt_bass::types::BroadcastReceiveState;
-use bt_bass::types::PaSync;
+use bt_bass::types::{BisSync, PaSync};
 use bt_common::core::PaInterval;
 use bt_common::packet_encoding::Error as PacketError;
 use bt_common::PeerId;
 #[cfg(any(test, feature = "debug"))]
 use bt_gatt::types::Handle;
+use std::collections::HashMap;
 
 use crate::assistant::DiscoveredBroadcastSources;
 
@@ -104,7 +105,7 @@
         source_peer_id: PeerId,
         address_lookup: &impl GetPeerAddr,
         pa_sync: PaSync,
-        bis_sync: BigToBisSync,
+        bis_sync: HashMap<u8, BisSync>,
     ) -> Result<(), Error> {
         let mut broadcast_source = self
             .broadcast_sources
@@ -148,7 +149,7 @@
         &self,
         broadcast_id: BroadcastId,
         pa_sync: PaSync,
-        bis_sync: BigToBisSync,
+        bis_sync: HashMap<u8, BisSync>,
     ) -> Result<(), Error> {
         let pa_interval = self
             .broadcast_sources
@@ -199,7 +200,7 @@
     use assert_matches::assert_matches;
     use bt_gatt::pii::StaticPeerAddr;
     use futures::{pin_mut, FutureExt};
-    use std::collections::HashSet;
+    use std::collections::HashMap;
     use std::task::Poll;
 
     use bt_common::core::{AddressType, AdvertisingSetId};
@@ -285,7 +286,7 @@
                 PeerId(1001),
                 &FakeGetPeerAddr,
                 PaSync::SyncPastUnavailable,
-                HashSet::new(),
+                HashMap::new(),
             );
             pin_mut!(fut);
             let polled = fut.poll_unpin(&mut noop_cx);
@@ -307,7 +308,7 @@
                 PeerId(1001),
                 &address_lookup,
                 PaSync::SyncPastUnavailable,
-                HashSet::new(),
+                HashMap::new(),
             );
             pin_mut!(fut);
             let polled = fut.poll_unpin(&mut noop_cx);
@@ -322,7 +323,7 @@
                 PeerId(1001),
                 &address_lookup,
                 PaSync::SyncPastUnavailable,
-                HashSet::new(),
+                HashMap::new(),
             );
             pin_mut!(fut);
             let polled = fut.poll_unpin(&mut noop_cx);
diff --git a/rust/bt-broadcast-assistant/src/debug.rs b/rust/bt-broadcast-assistant/src/debug.rs
index 6a4f308..1fe4f9e 100644
--- a/rust/bt-broadcast-assistant/src/debug.rs
+++ b/rust/bt-broadcast-assistant/src/debug.rs
@@ -5,20 +5,26 @@
 use bt_bap::types::BroadcastId;
 use bt_bass::client::error::Error as BassClientError;
 use bt_bass::client::event::Event as BassEvent;
-use bt_bass::client::BigToBisSync;
-use bt_bass::types::PaSync;
+use bt_bass::types::{BisSync, PaSync, SubgroupIndex};
+
+#[cfg(any(test, feature = "debug"))]
+use bt_common::core::ltv::LtValue;
+#[cfg(any(test, feature = "debug"))]
+use bt_common::core::{AddressType, AdvertisingSetId};
 use bt_common::debug_command::CommandRunner;
 use bt_common::debug_command::CommandSet;
 use bt_common::gen_commandset;
+#[cfg(any(test, feature = "debug"))]
+use bt_common::generic_audio::metadata_ltv::Metadata;
 use bt_common::PeerId;
 use bt_gatt::pii::GetPeerAddr;
+use std::collections::HashMap;
 
 use futures::stream::FusedStream;
 use futures::Future;
 use futures::Stream;
 use num::Num;
 use parking_lot::Mutex;
-use std::collections::HashSet;
 use std::num::ParseIntError;
 use std::sync::Arc;
 
@@ -33,13 +39,13 @@
         Connect = ("connect", [], ["peer_id"], "Attempt connection to scan delegator"),
         Disconnect = ("disconnect", [], [], "Disconnect from connected scan delegator"),
         SendBroadcastCode = ("set-broadcast-code", [], ["broadcast_id", "broadcast_code"], "Attempt to send decryption key for a particular broadcast source to the scan delegator"),
-        AddBroadcastSource = ("add-broadcast-source", [], ["broadcast_source_pid", "pa_sync", "[bis_sync]"], "Attempt to add a particular broadcast source to the scan delegator"),
-        UpdatePaSync = ("update-pa-sync", [], ["broadcast_id", "pa_sync", "[bis_sync]"], "Attempt to update the scan delegator's desired pa sync to a particular broadcast source"),
+        AddBroadcastSource = ("add-broadcast-source", [], ["broadcast_source_pid", "PaSyncOff|PaSyncPast|PaSyncNoPast", "[bis_sync]"], "Attempt to add a particular broadcast source to the scan delegator"),
+        UpdatePaSync = ("update-pa-sync", [], ["broadcast_id", "PaSyncOff|PaSyncPast|PaSyncNoPast", "[bis_sync]"], "Attempt to update the scan delegator's desired pa sync to a particular broadcast source"),
         RemoveBroadcastSource = ("remove-broadcast-source", [], ["broadcast_id"], "Attempt to remove a particular broadcast source to the scan delegator"),
         RemoteScanStarted = ("inform-scan-started", [], [], "Inform the scan delegator that we have started scanning on behalf of it"),
         RemoteScanStopped = ("inform-scan-stopped", [], [], "Inform the scan delegator that we have stopped scanning on behalf of it"),
         // TODO(http://b/433285146): Once PA scanning is implemented, remove bottom 3 commands.
-        ForceDiscoverBroadcastSource = ("force-discover-broadcast-source", [], ["broadcast_source_pid", "address", "address_type", "advertising_sid"], "Force the broadcast assistant to become aware of the provided broadcast source"),
+        ForceDiscoverBroadcastSource = ("force-discover-broadcast-source", [], ["broadcast_source_pid", "address", "Public|Random", "advertising_sid"], "Force the broadcast assistant to become aware of the provided broadcast source"),
         ForceDiscoverSourceMetadata = ("force-discover-source-metadata", [], ["broadcast_source_pid", "comma_separated_raw_metadata"], "Force the broadcast assistant to become aware of the provided metadata, each BIG's metadata is comma separated"),
         ForceDiscoverEmptySourceMetadata = ("force-discover-empty-source-metadata", [], ["broadcast_source_pid", "num_big"], "Force the broadcast assistant to become aware of the provided empty metadata, as many as # BIGs specified"),
     }
@@ -48,7 +54,6 @@
 pub struct AssistantDebug<T: bt_gatt::GattTypes, R: GetPeerAddr> {
     assistant: BroadcastAssistant<T>,
     connected_peer: Mutex<Option<Arc<Peer<T>>>>,
-    started: bool,
     peer_addr_getter: R,
 }
 
@@ -60,18 +65,16 @@
         Self {
             assistant: BroadcastAssistant::<T>::new(central),
             connected_peer: Mutex::new(None),
-            started: false,
             peer_addr_getter,
         }
     }
 
     pub fn start(&mut self) -> Result<EventStream<T>, Error> {
         let event_stream = self.assistant.start()?;
-        self.started = true;
         Ok(event_stream)
     }
 
-    pub fn look_for_scan_delegators(&mut self) -> T::ScanResultStream {
+    pub fn look_for_scan_delegators(&mut self) -> Result<T::ScanResultStream, Error> {
         self.assistant.scan_for_scan_delegators()
     }
 
@@ -118,7 +121,7 @@
     }
 }
 
-fn parse_peer_id(input: &str) -> Result<PeerId, String> {
+pub fn parse_peer_id(input: &str) -> Result<PeerId, String> {
     let raw_id = match parse_int(input) {
         Err(_) => return Err(format!("falied to parse int from {input}")),
         Ok(i) => i,
@@ -128,12 +131,14 @@
 }
 
 #[cfg(any(test, feature = "debug"))]
-fn parse_bd_addr(input: &str) -> Result<[u8; 6], String> {
-    let tokens: Vec<u8> =
+/// Returns the bd address in little endian ordering.
+pub fn parse_bd_addr(input: &str) -> Result<[u8; 6], String> {
+    let mut tokens: Vec<u8> =
         input.split(':').map(|t| u8::from_str_radix(t, 16)).filter_map(Result::ok).collect();
     if tokens.len() != 6 {
         return Err(format!("failed to parse bd address from {input}"));
     }
+    tokens.reverse();
     tokens.try_into().map_err(|e| format!("{e:?}"))
 }
 
@@ -145,17 +150,30 @@
     raw_id.try_into().map_err(|e| format!("{e:?}"))
 }
 
-fn parse_bis_sync(input: &str) -> BigToBisSync {
-    input.split(',').filter_map(|t| {
+fn parse_bis_sync(input: &str) -> HashMap<SubgroupIndex, BisSync> {
+    let mut map = HashMap::new();
+    for t in input.split(',') {
         let parts: Vec<_> = t.split('-').collect();
         if parts.len() != 2 {
-            eprintln!("invalid big-bis sync info {t}. should be in <Ith_BIG>-<BIS_INDEX> format, will be ignored");
-            return None;
+            eprintln!(
+                "invalid big-bis sync info {t}. should be in <Ith_BIG>-<BIS_INDEX> format, will be ignored"
+            );
+            continue;
         }
-        let ith_big = parse_int(parts[0]).ok()?;
-        let bis_index = parse_int(parts[1]).ok()?;
-        Some((ith_big, bis_index))
-    }).collect()
+        let Ok(ith_big) = parse_int(parts[0]) else {
+            eprintln!("Failed to parse big index from '{}', ignoring.", parts[0]);
+            continue;
+        };
+        let Ok(bis_index) = parse_int::<u8>(parts[1]) else {
+            eprintln!("Failed to parse bis index from '{}', ignoring.", parts[1]);
+            continue;
+        };
+        let entry = map.entry(ith_big).or_insert(BisSync::no_sync());
+        if let Err(e) = entry.synchronize_to_index(bis_index) {
+            eprintln!("Invalid BIS index: {e:?}");
+        }
+    }
+    map
 }
 
 impl<T: bt_gatt::GattTypes + 'static, R: GetPeerAddr> CommandRunner for AssistantDebug<T, R>
@@ -249,18 +267,16 @@
                         return Ok(());
                     };
 
-                    let pa_sync = match parse_int::<u8>(&args[1]) {
-                        Ok(raw_val) if PaSync::try_from(raw_val).is_ok() => {
-                            PaSync::try_from(raw_val).unwrap()
-                        }
-                        _ => {
-                            eprintln!("invalid pa_sync: {}", args[1]);
+                    let pa_sync: PaSync = match args[1].parse() {
+                        Ok(sync) => sync,
+                        Err(e) => {
+                            eprintln!("invalid pa_sync: {e:?}");
                             return Ok(());
                         }
                     };
 
                     let bis_sync =
-                        if args.len() == 3 { parse_bis_sync(&args[2]) } else { HashSet::new() };
+                        if args.len() == 3 { parse_bis_sync(&args[2]) } else { HashMap::new() };
 
                     self.with_peer(|peer| async move {
                         peer.add_broadcast_source(
@@ -284,18 +300,16 @@
                         return Ok(());
                     };
 
-                    let pa_sync = match parse_int::<u8>(&args[1]) {
-                        Ok(raw_val) if PaSync::try_from(raw_val).is_ok() => {
-                            PaSync::try_from(raw_val).unwrap()
-                        }
-                        _ => {
-                            eprintln!("invalid pa_sync: {}", args[1]);
+                    let pa_sync: PaSync = match args[1].parse() {
+                        Ok(sync) => sync,
+                        Err(e) => {
+                            eprintln!("invalid pa_sync: {e:?}");
                             return Ok(());
                         }
                     };
 
                     let bis_sync =
-                        if args.len() == 3 { parse_bis_sync(&args[2]) } else { HashSet::new() };
+                        if args.len() == 3 { parse_bis_sync(&args[2]) } else { HashMap::new() };
 
                     self.with_peer(|peer| async move {
                         peer.update_broadcast_source_sync(broadcast_id, pa_sync, bis_sync).await
@@ -319,8 +333,10 @@
                     .await;
                 }
                 AssistantCmd::RemoteScanStarted => {
-                    self.with_peer(|peer| async move { peer.inform_remote_scan_started().await })
-                        .await;
+                    self.with_peer(|peer: Arc<Peer<T>>| async move {
+                        peer.inform_remote_scan_started().await
+                    })
+                    .await;
                 }
                 AssistantCmd::RemoteScanStopped => {
                     self.with_peer(|peer| async move { peer.inform_remote_scan_stopped().await })
@@ -346,21 +362,25 @@
                         return Ok(());
                     };
 
-                    let Ok(raw_addr_type) = parse_int::<u8>(&args[2]) else {
-                        eprintln!("invalid address type: {}", args[2]);
-                        return Ok(());
+                    let address_type: AddressType = match args[2].parse() {
+                        Ok(t) => t,
+                        Err(e) => {
+                            eprintln!("invalid address type: {e:?}");
+                            return Ok(());
+                        }
                     };
 
                     let Ok(raw_ad_sid) = parse_int::<u8>(&args[3]) else {
                         eprintln!("invalid advertising sid: {}", args[3]);
                         return Ok(());
                     };
+                    let advertising_sid = AdvertisingSetId(raw_ad_sid);
 
                     match self.assistant.force_discover_broadcast_source(
                         peer_id,
                         address,
-                        raw_addr_type,
-                        raw_ad_sid,
+                        address_type,
+                        advertising_sid,
                     ) {
                         Ok(source) => {
                             eprintln!("broadcast source after additional info: {source:?}")
@@ -385,19 +405,32 @@
                         return Ok(());
                     };
 
-                    let mut raw_metadata = Vec::new();
+                    let mut all_big_metadata = Vec::new();
                     for i in 1..args.len() {
-                        let ith_metadata: Vec<u8> = args[i]
+                        let raw_metadata: Vec<u8> = args[i]
                             .split(',')
                             .map(|t| parse_int(t))
                             .filter_map(Result::ok)
                             .collect();
-                        raw_metadata.push(ith_metadata);
+
+                        if raw_metadata.len() > 0 {
+                            let (decoded_metadata, consumed_len) =
+                                Metadata::decode_all(raw_metadata.as_slice());
+                            if consumed_len != raw_metadata.len() {
+                                eprintln!("Metadata length is not valid");
+                                return Ok(());
+                            }
+                            all_big_metadata.push(
+                                decoded_metadata.into_iter().filter_map(Result::ok).collect(),
+                            );
+                        } else {
+                            all_big_metadata.push(vec![]);
+                        }
                     }
 
                     match self
                         .assistant
-                        .force_discover_broadcast_source_metadata(peer_id, raw_metadata)
+                        .force_discover_broadcast_source_metadata(peer_id, all_big_metadata)
                     {
                         Ok(source) => eprintln!("broadcast source with metadata: {source:?}"),
                         Err(e) => eprintln!("failed to enter in broadcast source metadata: {e:?}"),
@@ -423,14 +456,14 @@
                         return Ok(());
                     };
 
-                    let mut raw_metadata = Vec::new();
+                    let mut all_big_metadata = Vec::new();
                     for _i in 0..num_big {
-                        raw_metadata.push(vec![]);
+                        all_big_metadata.push(vec![]);
                     }
 
                     match self
                         .assistant
-                        .force_discover_broadcast_source_metadata(peer_id, raw_metadata)
+                        .force_discover_broadcast_source_metadata(peer_id, all_big_metadata)
                     {
                         Ok(source) => eprintln!("broadcast source with metadata: {source:?}"),
                         Err(e) => {
@@ -465,7 +498,7 @@
     fn test_parse_bd_addr() {
         assert_eq!(
             parse_bd_addr("3c:80:f1:ed:32:2c").expect("should be ok"),
-            [0x3c, 0x80, 0xf1, 0xed, 0x32, 0x2c]
+            [0x2c, 0x32, 0xed, 0xf1, 0x80, 0x3c]
         );
         // Address with 5 parts is invalid.
         let _ = parse_bd_addr("3c:80:f1:ed:32").expect_err("should fail");
@@ -492,16 +525,14 @@
     #[test]
     fn test_parse_bis_sync() {
         let bis_sync = parse_bis_sync("0-1,0-2,1-1");
-        assert_eq!(bis_sync.len(), 3);
-        bis_sync.contains(&(0, 1));
-        bis_sync.contains(&(0, 2));
-        bis_sync.contains(&(1, 1));
+        assert_eq!(bis_sync.len(), 2);
+        assert_eq!(bis_sync.get(&0), Some(&BisSync::sync(vec![1, 2]).unwrap()));
+        assert_eq!(bis_sync.get(&1), Some(&BisSync::sync(vec![1]).unwrap()));
 
         // Will ignore invalid values.
         let bis_sync = parse_bis_sync("0-1,0-2,1:1,1-1-1,");
-        assert_eq!(bis_sync.len(), 2);
-        bis_sync.contains(&(0, 1));
-        bis_sync.contains(&(0, 2));
+        assert_eq!(bis_sync.len(), 1);
+        assert_eq!(bis_sync.get(&0), Some(&BisSync::sync(vec![1, 2]).unwrap()));
 
         let bis_sync = parse_bis_sync("hellothisistoallynotvalid");
         assert_eq!(bis_sync.len(), 0);
diff --git a/rust/bt-broadcast-assistant/src/types.rs b/rust/bt-broadcast-assistant/src/types.rs
index 35d6c6e..2cd8d96 100644
--- a/rust/bt-broadcast-assistant/src/types.rs
+++ b/rust/bt-broadcast-assistant/src/types.rs
@@ -3,11 +3,11 @@
 // found in the LICENSE file.
 
 use bt_bap::types::*;
-use bt_bass::client::BigToBisSync;
 use bt_bass::types::{BigSubgroup, BisSync};
 use bt_common::core::{Address, AddressType};
 use bt_common::core::{AdvertisingSetId, PaInterval};
 use bt_common::packet_encoding::Error as PacketError;
+use std::collections::HashMap;
 
 /// Broadcast source data as advertised through Basic Audio Announcement
 /// PA and Broadcast Audio Announcement.
@@ -27,12 +27,10 @@
     /// Returns whether or not this BroadcastSource has enough information
     /// to be added by the Broadcast Assistant.
     pub(crate) fn into_add_source(&self) -> bool {
-        // PA interval is not necessary since default value can be used.
-        self.address.is_some()
-            && self.address_type.is_some()
-            && self.advertising_sid.is_some()
-            && self.broadcast_id.is_some()
-            && self.endpoint.is_some()
+        // Address and PA interval information are not necessary since
+        // default value can be used for PA interval and Address is looked up
+        // when the add source operation is triggered.
+        self.advertising_sid.is_some() && self.broadcast_id.is_some() && self.endpoint.is_some()
     }
 
     pub fn with_address(&mut self, address: [u8; 6]) -> &mut Self {
@@ -95,7 +93,7 @@
     ///   preference value is used for all the BIGs
     pub(crate) fn endpoint_to_big_subgroups(
         &self,
-        bis_sync: BigToBisSync,
+        bis_sync: HashMap<u8, BisSync>,
     ) -> Result<Vec<BigSubgroup>, PacketError> {
         if self.endpoint.is_none() {
             return Err(PacketError::InvalidParameter(
@@ -104,17 +102,9 @@
             ));
         }
         let mut subgroups = Vec::new();
-        let sync_map = bt_bass::client::big_to_bis_sync_indices(&bis_sync);
 
         for (big_index, group) in self.endpoint.as_ref().unwrap().big.iter().enumerate() {
-            let bis_sync = match sync_map.get(&(big_index as u8)) {
-                Some(bis_indices) => {
-                    let mut bis_sync: BisSync = BisSync(0);
-                    bis_sync.set_sync(bis_indices)?;
-                    bis_sync
-                }
-                _ => BisSync::default(),
-            };
+            let bis_sync = bis_sync.get(&(big_index as u8)).cloned().unwrap_or_default();
             subgroups.push(BigSubgroup::new(Some(bis_sync)).with_metadata(group.metadata.clone()));
         }
         Ok(subgroups)
@@ -125,7 +115,7 @@
 mod tests {
     use super::*;
 
-    use std::collections::HashSet;
+    use std::collections::HashMap;
 
     use bt_common::core::CodecId;
     use bt_common::generic_audio::metadata_ltv::Metadata;
@@ -135,19 +125,16 @@
         let mut b = BroadcastSource::default();
         assert!(!b.into_add_source());
 
-        b.merge(
-            &BroadcastSource::default()
-                .with_address([0x1, 0x2, 0x3, 0x4, 0x5, 0x6])
-                .with_address_type(AddressType::Public)
-                .with_advertising_sid(AdvertisingSetId(0x1))
-                .with_broadcast_id(BroadcastId::try_from(0x010203).unwrap()),
-        );
-
+        b.with_advertising_sid(AdvertisingSetId(0x1));
         assert!(!b.into_add_source());
-        b.endpoint_to_big_subgroups(HashSet::from([(0, 1)]))
+
+        b.with_broadcast_id(BroadcastId::try_from(0x010203).unwrap());
+        assert!(!b.into_add_source());
+
+        b.endpoint_to_big_subgroups(HashMap::from([(0, BisSync::sync(vec![1]).unwrap())]))
             .expect_err("should fail no endpoint data");
 
-        b.merge(&BroadcastSource::default().with_endpoint(BroadcastAudioSourceEndpoint {
+        b.with_endpoint(BroadcastAudioSourceEndpoint {
             presentation_delay_ms: 0x010203,
             big: vec![BroadcastIsochronousGroup {
                 codec_id: CodecId::Assigned(bt_common::core::CodingFormat::Cvsd),
@@ -158,15 +145,19 @@
                     codec_specific_config: vec![],
                 }],
             }],
-        }));
+        });
 
         assert!(b.into_add_source());
-        let subgroups =
-            b.endpoint_to_big_subgroups(HashSet::from([(0, 1), (1, 1)])).expect("should succeed");
+        let subgroups = b
+            .endpoint_to_big_subgroups(HashMap::from([
+                (0, BisSync::sync(vec![1]).unwrap()),
+                (1, BisSync::sync(vec![1]).unwrap()),
+            ]))
+            .expect("should succeed");
         assert_eq!(subgroups.len(), 1);
         assert_eq!(
             subgroups[0],
-            BigSubgroup::new(Some(BisSync(0x00000001)))
+            BigSubgroup::new(Some(BisSync::sync(vec![1]).unwrap()))
                 .with_metadata(vec![Metadata::BroadcastAudioImmediateRenderingFlag])
         );
     }
diff --git a/rust/bt-common/src/core.rs b/rust/bt-common/src/core.rs
index db4a1d9..fee3dc7 100644
--- a/rust/bt-common/src/core.rs
+++ b/rust/bt-common/src/core.rs
@@ -6,6 +6,7 @@
 pub mod ltv;
 
 use crate::packet_encoding::{Encodable, Error as PacketError};
+use std::str::FromStr;
 
 /// Bluetooth Device Address that uniquely identifies the device
 /// to another Bluetooth device.
@@ -36,6 +37,18 @@
     }
 }
 
+impl FromStr for AddressType {
+    type Err = PacketError;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        match s {
+            "Public" => Ok(AddressType::Public),
+            "Random" => Ok(AddressType::Random),
+            _ => Err(PacketError::InvalidParameter(format!("invalid address type: {s}"))),
+        }
+    }
+}
+
 /// Advertising Set ID which is 1 byte long.
 #[derive(Debug, Clone, Copy, PartialEq)]
 pub struct AdvertisingSetId(pub u8);
@@ -218,6 +231,16 @@
     use crate::packet_encoding::Decodable;
 
     use super::*;
+    use std::str::FromStr;
+
+    #[test]
+    fn address_type_from_str() {
+        let addr_type = AddressType::from_str("Public").expect("should succeed");
+        assert_eq!(addr_type, AddressType::Public);
+        let addr_type = AddressType::from_str("Random").expect("should succeed");
+        assert_eq!(addr_type, AddressType::Random);
+        AddressType::from_str("invalid").expect_err("should fail");
+    }
 
     #[test]
     fn encode_pa_interval() {