diff --git a/.buildconfig-android.yml b/.buildconfig-android.yml
index 821392bc9f..9d085a7bd6 100644
--- a/.buildconfig-android.yml
+++ b/.buildconfig-android.yml
@@ -1,4 +1,4 @@
-libraryVersion: 86.1.0
+libraryVersion: 86.2.0
 groupId: org.mozilla.appservices
 projects:
   autofill:
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 817621e3ab..ad9f138005 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,3 +1,21 @@
+# v86.2.0 (_2021-11-02_)
+
+[Full Changelog](https://github.com/mozilla/application-services/compare/v86.1.0...v86.2.0)
+
+## Push
+### What's Changed
+  - We've changed the database schema to avoid confusion about the state of subscriptions and
+    in particular, avoid `SQL: UNIQUE constraint failed: push_record.channel_id` errors
+    reported in [#4575](https://github.com/mozilla/application-services/issues/4575). This is
+    technically a breaking change as a dictionary described in the UDL changed, but in practice,
+    none of our consumers used it, so we are not declaring it as breaking in this context.
+
+## Logins
+
+### What's New
+
+  - Added support for recording telemetry when the logins encryption key needs to be regenerated.
+
 # v86.1.0 (_2021-10-27_)
 
 [Full Changelog](https://github.com/mozilla/application-services/compare/v86.0.0...v86.1.0)
@@ -24,6 +42,14 @@
     See [the Glean Changelog](https://github.com/mozilla/glean/blob/v42.0.1/CHANGELOG.md) for full details.
     (Note there is a breaking change in Rust, but that doesn't impact consumers of Application Services)
 
+# v86.0.1 (_2021-10-28_)
+
+[Full Changelog](https://github.com/mozilla/application-services/compare/v86.0.0...v86.0.1)
+## Logins
+### What's Changed
+- Downgraded the log level of some logs, so now they should not show up in Sentry.
+
+
 # v86.0.0 (_2021-10-13_)
 
 [Full Changelog](https://github.com/mozilla/application-services/compare/v85.4.1...v86.0.0)
@@ -36,6 +62,15 @@
     this change and have PRs in-progress.
     ([#4549](https://github.com/mozilla/application-services/pull/4549))
 
+# v85.4.2 (_2021-10-20_)
+
+[Full Changelog](https://github.com/mozilla/application-services/compare/v85.4.1...v85.4.2)
+
+## Nimbus
+### What's fixed
+- Fixed a bug in iOS where the installation date would be set to start of EPOCH ([#4597](https://github.com/mozilla/application-services/pull/4597))
+
+
 # v85.4.1 (_2021-10-08_)
 
 [Full Changelog](https://github.com/mozilla/application-services/compare/v85.4.0...v85.4.1)
diff --git a/CHANGES_UNRELEASED.md b/CHANGES_UNRELEASED.md
index 077788b4e7..4aba803a1c 100644
--- a/CHANGES_UNRELEASED.md
+++ b/CHANGES_UNRELEASED.md
@@ -2,7 +2,7 @@
 
 # Unreleased Changes
 
-[Full Changelog](https://github.com/mozilla/application-services/compare/v86.1.0...main)
+[Full Changelog](https://github.com/mozilla/application-services/compare/v86.2.0...main)
 
 <!-- WARNING: New entries should be added below this comment to ensure the `./automation/prepare-release.py` script works as expected.
 
diff --git a/Cargo.lock b/Cargo.lock
index c2dbf1a2cd..0d9150195b 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2385,6 +2385,7 @@ version = "0.1.0"
 dependencies = [
  "base64 0.12.3",
  "bincode",
+ "env_logger 0.8.4",
  "error-support",
  "hex",
  "lazy_static",
@@ -2396,6 +2397,7 @@ dependencies = [
  "serde_derive",
  "serde_json",
  "sql-support",
+ "tempfile",
  "thiserror",
  "uniffi",
  "uniffi_build",
diff --git a/components/logins/android/metrics.yaml b/components/logins/android/metrics.yaml
index ad8d7502db..547be05ece 100644
--- a/components/logins/android/metrics.yaml
+++ b/components/logins/android/metrics.yaml
@@ -18,6 +18,50 @@
 $schema: moz://mozilla.org/schemas/glean/metrics/1-0-0
 
 logins_store:
+  # These track when we need to regenerate the encryption key which causes all
+  # local data to be lost
+  key_regenerated_lost:
+    type: event
+    description: >
+      The encryption key was regenerated because it was lost
+    bugs:
+      - https://github.com/mozilla/application-services/issues/4554
+    data_reviews:
+      - https://github.com/mozilla/application-services/issues/4582
+    data_sensitivity:
+      - technical
+    notification_emails:
+      - synced-client-integrations@mozilla.com
+    expires: 2022-04-18
+
+  key_regenerated_corrupt:
+    type: event
+    description: >
+      The encryption key was regenerated because it didn't match the encrypted
+      data
+    bugs:
+      - https://github.com/mozilla/application-services/issues/4554
+    data_reviews:
+      - https://github.com/mozilla/application-services/issues/4582
+    data_sensitivity:
+      - technical
+    notification_emails:
+      - synced-client-integrations@mozilla.com
+    expires: 2022-04-18
+
+  key_regenerated_other:
+    type: event
+    description: >
+      The encryption key was regenerated for an unknown reason
+    bugs:
+      - https://github.com/mozilla/application-services/issues/4554
+    data_reviews:
+      - https://github.com/mozilla/application-services/issues/4582
+    data_sensitivity:
+      - technical
+    notification_emails:
+      - synced-client-integrations@mozilla.com
+    expires: 2022-04-18
 
   # These help us understand how much the logins store is being used, and
   # whether it's succeeding in the duties asked of it.  We'll use them to
diff --git a/components/logins/android/src/main/java/mozilla/appservices/logins/DatabaseLoginsStorage.kt b/components/logins/android/src/main/java/mozilla/appservices/logins/DatabaseLoginsStorage.kt
index f6ac5f6b80..a1c1ab92bd 100644
--- a/components/logins/android/src/main/java/mozilla/appservices/logins/DatabaseLoginsStorage.kt
+++ b/components/logins/android/src/main/java/mozilla/appservices/logins/DatabaseLoginsStorage.kt
@@ -174,6 +174,20 @@ fun recordMigrationMetrics(jsonString: String) {
     }
 }
 
+enum class KeyRegenerationEventReason {
+    Lost, Corrupt, Other,
+}
+
+fun recordKeyRegenerationEvent(reason: KeyRegenerationEventReason) {
+    // Avoid the deprecation warning when calling  `record()` without the optional EventExtras param
+    @Suppress("DEPRECATION")
+    when (reason) {
+        KeyRegenerationEventReason.Lost -> LoginsStoreMetrics.keyRegeneratedLost.record()
+        KeyRegenerationEventReason.Corrupt -> LoginsStoreMetrics.keyRegeneratedCorrupt.record()
+        KeyRegenerationEventReason.Other -> LoginsStoreMetrics.keyRegeneratedOther.record()
+    }
+}
+
 /**
  * A helper class for gathering basic count metrics on different kinds of LoginsStore operation.
  *
diff --git a/components/push/Cargo.toml b/components/push/Cargo.toml
index 22edc12aac..c630bafa9a 100644
--- a/components/push/Cargo.toml
+++ b/components/push/Cargo.toml
@@ -32,6 +32,8 @@ uniffi_build = { version = "^0.14", features=["builtin-bindgen"] }
 
 
 [dev-dependencies]
+env_logger = { version = "0.8", default-features = false, features = ["termcolor", "atty", "humantime"] }
 mockito = "0.27"
 hex = "0.4"
+tempfile = "3.1.0"
 viaduct-reqwest = { path = "../support/viaduct-reqwest" }
diff --git a/components/push/android/src/test/java/mozilla/appservices/push/PushTest.kt b/components/push/android/src/test/java/mozilla/appservices/push/PushTest.kt
index 12c17fa76b..916870b414 100644
--- a/components/push/android/src/test/java/mozilla/appservices/push/PushTest.kt
+++ b/components/push/android/src/test/java/mozilla/appservices/push/PushTest.kt
@@ -75,12 +75,13 @@ class PushTest {
             "1bkHMoiw4b6L7YTyF8foLEEU"
 
     protected fun getPushManager(): PushManager {
-        return PushManager(
+        val pm = PushManager(
                 senderId = mockSenderId,
                 bridgeType = BridgeType.TEST,
-                registrationId = "TestRegistrationId",
                 databasePath = dbFile
         )
+        pm.update("TestRegistrationId")
+        return pm
     }
 
     /* Usage:
@@ -243,7 +244,6 @@ class PushTest {
 
         manager.subscribe(testChannelid, "foo", vapidPubKey)
         val dispatch = manager.dispatchInfoForChid(testChannelid)!!
-        assertEquals("uaid", "abad1d3a00000000aabbccdd00000000", dispatch.uaid)
         assertEquals("scope", "foo", dispatch.scope)
         assert(dispatch.endpoint.length > 0)
         assertEquals(dispatch.appServerKey, vapidPubKey)
diff --git a/components/push/src/internal/communications.rs b/components/push/src/internal/communications.rs
index 2b3d47f2e2..09e4bd0cd4 100644
--- a/components/push/src/internal/communications.rs
+++ b/components/push/src/internal/communications.rs
@@ -44,9 +44,6 @@ pub struct RegisterResponse {
 
     /// Push endpoint for 3rd parties
     pub endpoint: String,
-
-    /// The Sender/Group ID echoed back (if applicable.)
-    pub senderid: Option<String>,
 }
 
 #[derive(Serialize, Deserialize)]
@@ -97,7 +94,8 @@ pub trait Connection {
 pub struct ConnectHttp {
     pub options: PushConfiguration,
     pub uaid: Option<String>,
-    pub auth: Option<String>, // Server auth token
+    pub auth: Option<String>,            // Server auth token
+    pub registration_id: Option<String>, // Eg, the FCM/iOS native ID
 }
 
 // Connect to the Autopush server
@@ -105,6 +103,7 @@ pub fn connect(
     options: PushConfiguration,
     uaid: Option<String>,
     auth: Option<String>,
+    registration_id: Option<String>,
 ) -> error::Result<ConnectHttp> {
     // find connection via options
 
@@ -116,18 +115,12 @@ pub fn connect(
     if options.socket_protocol.is_some() {
         return Err(CommunicationError("Unsupported".to_owned()).into());
     };
-    if options.bridge_type.is_some() && options.registration_id.is_none() {
-        return Err(CommunicationError(
-            "Missing Registration ID, please register with OS first".to_owned(),
-        )
-        .into());
-    };
     let connection = ConnectHttp {
         options,
         uaid,
         auth,
+        registration_id,
     };
-
     Ok(connection)
 }
 
@@ -179,15 +172,19 @@ impl ConnectHttp {
         Ok(())
     }
 
-    fn format_unsubscribe_url(&self) -> String {
-        format!(
+    fn format_unsubscribe_url(&self) -> error::Result<String> {
+        let uaid = match &self.uaid {
+            Some(u) => u,
+            _ => return Err(CommunicationError("No UAID set".into()).into()),
+        };
+        Ok(format!(
             "{}://{}/v1/{}/{}/registration/{}",
             &self.options.http_protocol.as_ref().unwrap(),
             &self.options.server_host,
             &self.options.bridge_type.as_ref().unwrap(),
             &self.options.sender_id,
-            &self.uaid.clone().unwrap(),
-        )
+            &uaid,
+        ))
     }
 }
 
@@ -220,7 +217,22 @@ impl Connection for ConnectHttp {
             url.push_str("/subscription");
         }
         let mut body = HashMap::new();
-        body.insert("token", options.registration_id.unwrap());
+        // Ideally we'd store "expected" subscriptions in the DB separate from "actual" ones, and
+        // then we could record this as "expected" and perform the actual subscription once we
+        // learn our registration_id - but for now we can't do anything subscription related
+        // without a registration_id.
+        body.insert(
+            "token",
+            match &self.registration_id {
+                Some(r) => r.to_owned(),
+                None => {
+                    return Err(CommunicationError(
+                        "Can't subscribe until we have a native registration id".to_string(),
+                    )
+                    .into())
+                }
+            },
+        );
         body.insert("channelID", channel_id.to_owned());
         if let Some(key) = app_server_key {
             body.insert("key", key.to_owned());
@@ -238,7 +250,6 @@ impl Connection for ConnectHttp {
                 channel_id: "deadbeef00000000decafbad00000000".to_owned(),
                 secret: self.auth.clone(),
                 endpoint: "http://push.example.com/test/opaque".to_owned(),
-                senderid: Some(self.options.sender_id.clone()),
             });
         }
         let response = Request::post(Url::parse(&url)?)
@@ -253,40 +264,45 @@ impl Connection for ConnectHttp {
         );
         self.check_response_error(&response)?;
         let response: Value = response.json()?;
-
-        if self.uaid.is_none() {
-            self.uaid = response["uaid"].as_str().map(ToString::to_string);
-        }
-        if self.auth.is_none() {
-            self.auth = response["secret"].as_str().map(ToString::to_string);
+        // asserting here seems bad! :) But what does this mean? We supplied ours, how could
+        // the server disagree? (The server seems to only supply this if the UAID changed?)
+        if let Some(sid) = response["senderid"].as_str() {
+            assert_eq!(sid, options.sender_id, "`senderid` is confused?");
         }
 
-        let channel_id = response["channelID"].as_str().map(ToString::to_string);
-        let endpoint = response["endpoint"].as_str().map(ToString::to_string);
+        // helper to force "mandatory" fields in the response.
+        let ensure_resp_field = |name: &str| -> error::Result<String> {
+            match response[name].as_str() {
+                Some(s) => Ok(s.to_string()),
+                None => Err(CommunicationError(format!("response has no `{}`", name)).into()),
+            }
+        };
 
+        // uaid (same or different) is always returned.
+        let uaid = ensure_resp_field("uaid")?;
+        // secret only returned when uaid changes.
+        let secret = response["secret"].as_str().map(ToString::to_string);
+        // XXX - we only update `self.` here due to tests. We should fix the tests, and while at
+        // it, drop the `&mut self` everywhere, to further force the requirement that it be short
+        // lived.
+        self.uaid = Some(uaid.clone());
+        self.auth = secret.clone();
         Ok(RegisterResponse {
-            uaid: self.uaid.clone().unwrap(),
-            channel_id: channel_id.unwrap(),
-            secret: self.auth.clone(),
-            endpoint: endpoint.unwrap(),
-            senderid: response["senderid"].as_str().map(ToString::to_string),
+            uaid,
+            secret,
+            channel_id: ensure_resp_field("channelID")?,
+            endpoint: ensure_resp_field("endpoint")?,
         })
     }
 
     /// Drop a channel and stop receiving updates.
     fn unsubscribe(&self, channel_id: &str) -> error::Result<()> {
-        if self.auth.is_none() {
-            return Err(CommunicationError("Connection is unauthorized".into()).into());
-        }
-        if self.uaid.is_none() {
-            return Err(CommunicationError("No UAID set".into()).into());
-        }
         if &self.options.sender_id == "test" {
             return Ok(());
         }
         let url = format!(
             "{}/subscription/{}",
-            self.format_unsubscribe_url(),
+            self.format_unsubscribe_url()?,
             channel_id
         );
         let response = Request::delete(Url::parse(&url)?)
@@ -298,23 +314,18 @@ impl Connection for ConnectHttp {
     }
 
     /// Drops all channels and stops receiving notifications.
-    /// this also wipes the `uaid` and the `auth` fields.
     fn unsubscribe_all(&mut self) -> error::Result<()> {
-        if self.auth.is_none() {
-            return Err(CommunicationError("Connection is unauthorized".into()).into());
-        }
-        if self.uaid.is_none() {
-            return Err(CommunicationError("No UAID set".into()).into());
-        }
         if &self.options.sender_id == "test" {
             return Ok(());
         }
-        let url = self.format_unsubscribe_url();
+        let url = self.format_unsubscribe_url()?;
         let response = Request::delete(Url::parse(&url)?)
             .headers(self.headers()?)
             .send()?;
         log::info!("unsubscribed from all via {}: {}", url, response.status);
         self.check_response_error(&response)?;
+        // theoretically no need to kill our uaid etc here - this connection is short-lived, and
+        // our caller is what must kill the persisted version - but tests still use it.
         self.uaid = None;
         self.auth = None;
         Ok(())
@@ -327,13 +338,13 @@ impl Connection for ConnectHttp {
             self.auth = Some("LsuUOBKVQRY6-l7_Ajo-Ag".to_owned());
             return Ok(());
         }
-        if self.auth.is_none() {
-            return Err(CommunicationError("Connection is unauthorized".into()).into());
-        }
-        if self.uaid.is_none() {
-            return Err(CommunicationError("No UAID set".into()).into());
-        }
-        self.options.registration_id = Some(new_token.to_owned());
+        let uaid = match &self.uaid {
+            Some(u) => u,
+            _ => return Err(CommunicationError("No UAID set".into()).into()),
+        };
+        // Updating `self.registration_id` shouldn't be necessary - `self` should not live beyond
+        // this call and it's our caller who persists the new value and supplies it.
+        self.registration_id = Some(new_token.to_string());
         let options = self.options.clone();
         let url = format!(
             "{}://{}/v1/{}/{}/registration/{}",
@@ -341,7 +352,7 @@ impl Connection for ConnectHttp {
             &options.server_host,
             &options.bridge_type.unwrap(),
             &options.sender_id,
-            &self.uaid.clone().unwrap()
+            uaid
         );
         let mut body = HashMap::new();
         body.insert("token", new_token);
@@ -423,9 +434,6 @@ impl Connection for ConnectHttp {
     /// should force the client to drop the old UAID, request a new UAID from the server, and
     /// resubscribe all channels, resulting in new endpoints.
     fn verify_connection(&mut self, channels: &[String]) -> error::Result<bool> {
-        if self.auth.is_none() {
-            return Err(CommunicationError("Connection uninitiated".to_owned()).into());
-        }
         if &self.options.sender_id == "test" {
             return Ok(false);
         }
@@ -434,8 +442,8 @@ impl Connection for ConnectHttp {
             Ok(v) => HashSet::from_iter(v),
             Err(e) => match e.kind() {
                 UAIDNotRecognizedError(_) => {
-                    // We do not unsubscribe, because the
-                    // server already lost our UAID
+                    // We do not unsubscribe, because the server already lost our UAID
+                    // XXX - update `self` just for tests. Should kill `&mut self`
                     self.uaid = None;
                     self.auth = None;
                     return Ok(false);
@@ -488,7 +496,6 @@ mod test {
             server_host: server_address().to_string(),
             sender_id: SENDER_ID.to_owned(),
             bridge_type: Some("test".to_owned()),
-            registration_id: Some("SomeRegistrationValue".to_owned()),
             ..Default::default()
         };
         // SUBSCRIPTION with secret
@@ -509,7 +516,8 @@ mod test {
             .with_header("content-type", "application/json")
             .with_body(body)
             .create();
-            let mut conn = connect(config.clone(), None, None).unwrap();
+            let mut conn =
+                connect(config.clone(), None, None, Some(SENDER_ID.to_string())).unwrap();
             let channel_id = hex::encode(crate::internal::crypto::get_random_bytes(16).unwrap());
             let response = conn.subscribe(&channel_id, None).unwrap();
             ap_mock.assert();
@@ -535,7 +543,8 @@ mod test {
             .with_header("content-type", "application/json")
             .with_body(body)
             .create();
-            let mut conn = connect(config.clone(), None, None).unwrap();
+            let mut conn =
+                connect(config.clone(), None, None, Some(SENDER_ID.to_string())).unwrap();
             let channel_id = hex::encode(crate::internal::crypto::get_random_bytes(16).unwrap());
             let response = conn.subscribe(&channel_id, None).unwrap();
             ap_ns_mock.assert();
@@ -562,6 +571,7 @@ mod test {
                 config.clone(),
                 Some(DUMMY_UAID.to_owned()),
                 Some(SECRET.to_owned()),
+                None,
             )
             .unwrap();
             conn.unsubscribe(DUMMY_CHID).unwrap();
@@ -582,6 +592,7 @@ mod test {
                 config.clone(),
                 Some(DUMMY_UAID.to_owned()),
                 Some(SECRET.to_owned()),
+                None,
             )
             .unwrap();
             //TODO: Add record to nuke.
@@ -603,15 +614,13 @@ mod test {
                 config.clone(),
                 Some(DUMMY_UAID.to_owned()),
                 Some(SECRET.to_owned()),
+                Some("native-id".to_string()),
             )
             .unwrap();
 
             conn.update("NewTokenValue").unwrap();
             ap_mock.assert();
-            assert_eq!(
-                conn.options.registration_id,
-                Some("NewTokenValue".to_owned())
-            );
+            assert_eq!(conn.registration_id, Some("NewTokenValue".to_owned()));
         }
         // CHANNEL LIST
         {
@@ -629,8 +638,13 @@ mod test {
             .with_header("content-type", "application/json")
             .with_body(body_cl_success)
             .create();
-            let conn =
-                connect(config, Some(DUMMY_UAID.to_owned()), Some(SECRET.to_owned())).unwrap();
+            let conn = connect(
+                config,
+                Some(DUMMY_UAID.to_owned()),
+                Some(SECRET.to_owned()),
+                None,
+            )
+            .unwrap();
             let response = conn.channel_list().unwrap();
             ap_mock.assert();
             assert!(response == [DUMMY_CHID.to_owned()]);
@@ -644,7 +658,6 @@ mod test {
                 server_host: server_address().to_string(),
                 sender_id: SENDER_ID.to_owned(),
                 bridge_type: Some("test".to_owned()),
-                registration_id: Some("SomeRegistrationValue".to_owned()),
                 ..Default::default()
             };
             // We first subscribe to get a UAID
@@ -664,7 +677,7 @@ mod test {
             .with_header("content-type", "application/json")
             .with_body(body)
             .create();
-            let mut conn = connect(config, None, None).unwrap();
+            let mut conn = connect(config, None, None, Some(SENDER_ID.to_string())).unwrap();
             let channel_id = hex::encode(crate::internal::crypto::get_random_bytes(16).unwrap());
             let response = conn.subscribe(&channel_id, None).unwrap();
             ap_mock.assert();
@@ -704,6 +717,8 @@ mod test {
             // after the mismatch, we unsubscribed, thus we expect that we wiped the UAID
             // from the conn object too
             assert!(conn.uaid.is_none());
+            // But the native id isn't wiped
+            assert!(conn.registration_id.is_some());
             // we now test that when we send a new subscribe
             // we'll store the new UAID the server gets us
             let body = json!({
@@ -737,7 +752,6 @@ mod test {
                 server_host: server_address().to_string(),
                 sender_id: SENDER_ID.to_owned(),
                 bridge_type: Some("test".to_owned()),
-                registration_id: Some("SomeRegistrationValue".to_owned()),
                 ..Default::default()
             };
             // We first subscribe to get a UAID
@@ -757,7 +771,7 @@ mod test {
             .with_header("content-type", "application/json")
             .with_body(body)
             .create();
-            let mut conn = connect(config, None, None).unwrap();
+            let mut conn = connect(config, None, None, Some(SENDER_ID.to_string())).unwrap();
             let channel_id = hex::encode(crate::internal::crypto::get_random_bytes(16).unwrap());
             let response = conn.subscribe(&channel_id, None).unwrap();
             ap_mock.assert();
@@ -799,7 +813,6 @@ mod test {
                 server_host: server_address().to_string(),
                 sender_id: SENDER_ID.to_owned(),
                 bridge_type: Some("test".to_owned()),
-                registration_id: Some("SomeRegistrationValue".to_owned()),
                 ..Default::default()
             };
             // We first subscribe to get a UAID
@@ -819,7 +832,7 @@ mod test {
             .with_header("content-type", "application/json")
             .with_body(body)
             .create();
-            let mut conn = connect(config, None, None).unwrap();
+            let mut conn = connect(config, None, None, Some(SENDER_ID.to_string())).unwrap();
             let channel_id = hex::encode(crate::internal::crypto::get_random_bytes(16).unwrap());
             let response = conn.subscribe(&channel_id, None).unwrap();
             ap_mock.assert();
@@ -862,7 +875,6 @@ mod test {
                 server_host: server_address().to_string(),
                 sender_id: SENDER_ID.to_owned(),
                 bridge_type: Some("test".to_owned()),
-                registration_id: Some("SomeRegistrationValue".to_owned()),
                 ..Default::default()
             };
             // We first subscribe to get a UAID
@@ -882,7 +894,7 @@ mod test {
             .with_header("content-type", "application/json")
             .with_body(body)
             .create();
-            let mut conn = connect(config, None, None).unwrap();
+            let mut conn = connect(config, None, None, Some(SENDER_ID.to_string())).unwrap();
             let channel_id = hex::encode(crate::internal::crypto::get_random_bytes(16).unwrap());
             let response = conn.subscribe(&channel_id, None).unwrap();
             ap_mock.assert();
@@ -927,7 +939,6 @@ mod test {
                 server_host: server_address().to_string(),
                 sender_id: SENDER_ID.to_owned(),
                 bridge_type: Some("test".to_owned()),
-                registration_id: Some("SomeRegistrationValue".to_owned()),
                 ..Default::default()
             };
             // We mock that the server thinks
@@ -948,7 +959,7 @@ mod test {
             .with_header("content-type", "application/json")
             .with_body(body)
             .create();
-            let mut conn = connect(config, None, None).unwrap();
+            let mut conn = connect(config, None, None, Some(SENDER_ID.to_string())).unwrap();
             let channel_id = hex::encode(crate::internal::crypto::get_random_bytes(16).unwrap());
             let err = conn.subscribe(&channel_id, None).unwrap_err();
             ap_mock.assert();
diff --git a/components/push/src/internal/config.rs b/components/push/src/internal/config.rs
index aa361f765b..dfba5cba07 100644
--- a/components/push/src/internal/config.rs
+++ b/components/push/src/internal/config.rs
@@ -16,9 +16,6 @@ pub struct PushConfiguration {
     /// bridge protocol ("fcm")
     pub bridge_type: Option<String>,
 
-    /// Native OS registration ID value
-    pub registration_id: Option<String>,
-
     /// Service enabled flag
     pub enabled: bool,
 
@@ -39,7 +36,6 @@ impl Default for PushConfiguration {
             socket_protocol: None,
             http_protocol: Some(String::from("https")),
             bridge_type: Some(String::from("fcm")),
-            registration_id: Some(String::from("deafbeef00000000")),
             enabled: true,
             ping_interval: 1800,
             sender_id: String::from(""),
diff --git a/components/push/src/internal/error.rs b/components/push/src/internal/error.rs
index 53ccb84c98..f3da84f565 100644
--- a/components/push/src/internal/error.rs
+++ b/components/push/src/internal/error.rs
@@ -37,8 +37,8 @@ pub enum ErrorKind {
     #[error("Storage Error: {0:?}")]
     StorageError(String),
 
-    #[error("No record for uaid:chid {0:?}:{1:?}")]
-    RecordNotFoundError(String, String),
+    #[error("No record for chid {0:?}")]
+    RecordNotFoundError(String),
 
     /// A failure to encode data to/from storage.
     #[error("Error executing SQL: {0}")]
diff --git a/components/push/src/internal/storage/db.rs b/components/push/src/internal/storage/db.rs
index de17db6276..774a6833cf 100644
--- a/components/push/src/internal/storage/db.rs
+++ b/components/push/src/internal/storage/db.rs
@@ -3,7 +3,7 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 use std::{ops::Deref, path::Path};
 
-use rusqlite::Connection;
+use rusqlite::{Connection, NO_PARAMS};
 use sql_support::{open_database, ConnExt};
 
 use crate::internal::error::{ErrorKind, Result};
@@ -13,24 +13,32 @@ use super::{record::PushRecord, schema};
 // TODO: Add broadcasts storage
 
 pub trait Storage {
-    fn get_record(&self, uaid: &str, chid: &str) -> Result<Option<PushRecord>>;
+    fn get_record(&self, chid: &str) -> Result<Option<PushRecord>>;
 
     fn get_record_by_chid(&self, chid: &str) -> Result<Option<PushRecord>>;
 
     fn put_record(&self, record: &PushRecord) -> Result<bool>;
 
-    fn delete_record(&self, uaid: &str, chid: &str) -> Result<bool>;
+    fn delete_record(&self, chid: &str) -> Result<bool>;
 
-    fn delete_all_records(&self, uaid: &str) -> Result<()>;
+    fn delete_all_records(&self) -> Result<()>;
 
-    fn get_channel_list(&self, uaid: &str) -> Result<Vec<String>>;
+    fn get_channel_list(&self) -> Result<Vec<String>>;
 
-    fn update_endpoint(&self, uaid: &str, channel_id: &str, endpoint: &str) -> Result<bool>;
+    fn update_endpoint(&self, channel_id: &str, endpoint: &str) -> Result<bool>;
 
-    fn update_native_id(&self, uaid: &str, native_id: &str) -> Result<bool>;
+    // Some of our "meta" keys are more important than others, so they get special helpers.
+    fn get_uaid(&self) -> Result<Option<String>>;
+    fn set_uaid(&self, uaid: &str) -> Result<()>;
 
-    fn get_meta(&self, key: &str) -> Result<Option<String>>;
+    fn get_auth(&self) -> Result<Option<String>>;
+    fn set_auth(&self, auth: &str) -> Result<()>;
+
+    fn get_registration_id(&self) -> Result<Option<String>>;
+    fn set_registration_id(&self, native_id: &str) -> Result<()>;
 
+    // And general purpose meta with hard-coded key names spread everywhere.
+    fn get_meta(&self, key: &str) -> Result<Option<String>>;
     fn set_meta(&self, key: &str, value: &str) -> Result<()>;
 }
 
@@ -44,16 +52,21 @@ impl PushDb {
         // By default, file open errors are StorageSqlErrors and aren't super helpful.
         // Instead, remap to StorageError and provide the path to the file that couldn't be opened.
         let initializer = schema::PushConnectionInitializer {};
-        let db = open_database::open_database(path, &initializer).map_err(|_| {
+        let db = open_database::open_database(path, &initializer).map_err(|orig| {
             ErrorKind::StorageError(format!(
-                "Could not open database file {:?}",
-                &path.as_os_str()
+                "Could not open database file {:?} - {}",
+                &path.as_os_str(),
+                orig,
             ))
         })?;
         Ok(Self { db })
     }
 
     pub fn open_in_memory() -> Result<Self> {
+        // A nod to our tests which use this.
+        #[cfg(test)]
+        env_logger::try_init().ok();
+
         let initializer = schema::PushConnectionInitializer {};
         let db = open_database::open_memory_database(&initializer)?;
         Ok(Self { db })
@@ -98,15 +111,15 @@ impl ConnExt for PushDb {
 }
 
 impl Storage for PushDb {
-    fn get_record(&self, uaid: &str, chid: &str) -> Result<Option<PushRecord>> {
+    fn get_record(&self, chid: &str) -> Result<Option<PushRecord>> {
         let query = format!(
             "SELECT {common_cols}
-             FROM push_record WHERE uaid = :uaid AND channel_id = :chid",
+             FROM push_record WHERE channel_id = :chid",
             common_cols = schema::COMMON_COLS,
         );
         self.try_query_row(
             &query,
-            &[(":uaid", &uaid), (":chid", &Self::normalize_uuid(chid))],
+            &[(":chid", &Self::normalize_uuid(chid))],
             PushRecord::from_row,
             false,
         )
@@ -127,87 +140,102 @@ impl Storage for PushDb {
     }
 
     fn put_record(&self, record: &PushRecord) -> Result<bool> {
+        log::debug!(
+            "adding push subscription for scope '{}', channel '{}', endpoint '{}'",
+            record.scope,
+            record.channel_id,
+            record.endpoint
+        );
         let query = format!(
-            "INSERT INTO push_record
+            "INSERT OR REPLACE INTO push_record
                  ({common_cols})
              VALUES
-                 (:uaid, :channel_id, :endpoint, :scope, :key, :ctime, :app_server_key, :native_id)
-             ON CONFLICT(uaid, channel_id) DO UPDATE SET
-                 uaid = :uaid,
-                 endpoint = :endpoint,
-                 scope = :scope,
-                 key = :key,
-                 ctime = :ctime,
-                 app_server_key = :app_server_key,
-                 native_id = :native_id",
+                 (:channel_id, :endpoint, :scope, :key, :ctime, :app_server_key)",
             common_cols = schema::COMMON_COLS,
         );
         let affected_rows = self.execute_named(
             &query,
             &[
-                (":uaid", &record.uaid),
                 (":channel_id", &Self::normalize_uuid(&record.channel_id)),
                 (":endpoint", &record.endpoint),
                 (":scope", &record.scope),
                 (":key", &record.key),
                 (":ctime", &record.ctime),
                 (":app_server_key", &record.app_server_key),
-                (":native_id", &record.native_id),
             ],
         )?;
         Ok(affected_rows == 1)
     }
 
-    fn delete_record(&self, uaid: &str, chid: &str) -> Result<bool> {
+    fn delete_record(&self, chid: &str) -> Result<bool> {
+        log::debug!("deleting push subscription: {}", chid);
         let affected_rows = self.execute_named(
             "DELETE FROM push_record
-             WHERE uaid = :uaid AND channel_id = :chid",
-            &[(":uaid", &uaid), (":chid", &Self::normalize_uuid(chid))],
+             WHERE channel_id = :chid",
+            &[(":chid", &Self::normalize_uuid(chid))],
         )?;
         Ok(affected_rows == 1)
     }
 
-    fn delete_all_records(&self, uaid: &str) -> Result<()> {
-        self.execute_named(
-            "DELETE FROM push_record WHERE uaid = :uaid",
-            &[(":uaid", &uaid)],
-        )?;
+    fn delete_all_records(&self) -> Result<()> {
+        log::debug!("deleting all push subscriptions and some metadata");
+        self.execute("DELETE FROM push_record", NO_PARAMS)?;
         // Clean up the meta data records as well, since we probably want to reset the
         // UAID and get a new secret.
+        // Note we *do not* delete the registration_id - it's possible we are deleting all
+        // subscriptions because we just provided a different registration_id.
         self.execute_batch(
-            "DELETE FROM meta_data WHERE key='uaid';\
-             DELETE FROM meta_data WHERE key='auth';",
+            "DELETE FROM meta_data WHERE key='uaid';
+             DELETE FROM meta_data WHERE key='auth';
+             ",
         )?;
         Ok(())
     }
 
-    fn get_channel_list(&self, uaid: &str) -> Result<Vec<String>> {
+    fn get_channel_list(&self) -> Result<Vec<String>> {
         self.query_rows_and_then_named(
-            "SELECT channel_id FROM push_record WHERE uaid = :uaid",
-            &[(":uaid", &uaid)],
+            "SELECT channel_id FROM push_record",
+            &[],
             |row| -> Result<String> { Ok(row.get(0)?) },
         )
     }
 
-    fn update_endpoint(&self, uaid: &str, channel_id: &str, endpoint: &str) -> Result<bool> {
+    fn update_endpoint(&self, channel_id: &str, endpoint: &str) -> Result<bool> {
+        log::debug!("updating endpoint for '{}' to '{}'", channel_id, endpoint);
         let affected_rows = self.execute_named(
             "UPDATE push_record set endpoint = :endpoint
-             WHERE uaid = :uaid AND channel_id = :channel_id",
+             WHERE channel_id = :channel_id",
             &[
                 (":endpoint", &endpoint),
-                (":uaid", &uaid),
                 (":channel_id", &Self::normalize_uuid(channel_id)),
             ],
         )?;
         Ok(affected_rows == 1)
     }
 
-    fn update_native_id(&self, uaid: &str, native_id: &str) -> Result<bool> {
-        let affected_rows = self.execute_named(
-            "UPDATE push_record set native_id = :native_id WHERE uaid = :uaid",
-            &[(":native_id", &native_id), (":uaid", &uaid)],
-        )?;
-        Ok(affected_rows == 1)
+    // A couple of helpers to get/set "well known" meta keys.
+    fn get_uaid(&self) -> Result<Option<String>> {
+        self.get_meta("uaid")
+    }
+
+    fn set_uaid(&self, uaid: &str) -> Result<()> {
+        self.set_meta("uaid", uaid)
+    }
+
+    fn get_auth(&self) -> Result<Option<String>> {
+        self.get_meta("auth")
+    }
+
+    fn set_auth(&self, auth: &str) -> Result<()> {
+        self.set_meta("auth", auth)
+    }
+
+    fn get_registration_id(&self) -> Result<Option<String>> {
+        self.get_meta("registration_id")
+    }
+
+    fn set_registration_id(&self, registration_id: &str) -> Result<()> {
+        self.set_meta("registration_id", registration_id)
     }
 
     fn get_meta(&self, key: &str) -> Result<Option<String>> {
@@ -240,6 +268,7 @@ mod test {
     const DUMMY_UAID: &str = "abad1dea00000000aabbccdd00000000";
 
     fn get_db() -> Result<PushDb> {
+        env_logger::try_init().ok();
         // NOTE: In Memory tests can sometimes produce false positives. Use the following
         // for debugging
         // PushDb::open("/tmp/push.sqlite");
@@ -256,7 +285,6 @@ mod test {
 
     fn prec(chid: &str) -> PushRecord {
         PushRecord::new(
-            DUMMY_UAID,
             chid,
             &format!("https://example.com/update/{}", chid),
             "https://example.com/",
@@ -270,18 +298,18 @@ mod test {
         let chid = &get_uuid()?;
         let rec = prec(chid);
 
-        assert!(db.get_record(DUMMY_UAID, chid)?.is_none());
+        assert!(db.get_record(chid)?.is_none());
         db.put_record(&rec)?;
-        assert!(db.get_record(DUMMY_UAID, chid)?.is_some());
+        assert!(db.get_record(chid)?.is_some());
         // don't fail if you've already added this record.
         db.put_record(&rec)?;
         // make sure that fetching the same uaid & chid returns the same record.
-        assert_eq!(db.get_record(DUMMY_UAID, chid)?, Some(rec.clone()));
+        assert_eq!(db.get_record(chid)?, Some(rec.clone()));
 
         let mut rec2 = rec.clone();
         rec2.endpoint = format!("https://example.com/update2/{}", chid);
         db.put_record(&rec2)?;
-        let result = db.get_record(DUMMY_UAID, chid)?.unwrap();
+        let result = db.get_record(chid)?.unwrap();
         assert_ne!(result, rec);
         assert_eq!(result, rec2);
         Ok(())
@@ -294,9 +322,9 @@ mod test {
         let rec = prec(chid);
 
         assert!(db.put_record(&rec)?);
-        assert!(db.get_record(DUMMY_UAID, chid)?.is_some());
-        assert!(db.delete_record(DUMMY_UAID, chid)?);
-        assert!(db.get_record(DUMMY_UAID, chid)?.is_none());
+        assert!(db.get_record(chid)?.is_some());
+        assert!(db.delete_record(chid)?);
+        assert!(db.get_record(chid)?.is_none());
         Ok(())
     }
 
@@ -310,13 +338,16 @@ mod test {
         rec2.endpoint = format!("https://example.com/update/{}", &rec2.channel_id);
 
         assert!(db.put_record(&rec)?);
+        // save a record with different channel and endpoint, but same scope - it should overwrite
+        // the first because scopes are unique.
         assert!(db.put_record(&rec2)?);
-        assert!(db.get_record(DUMMY_UAID, &rec.channel_id)?.is_some());
-        db.delete_all_records(DUMMY_UAID)?;
-        assert!(db.get_record(DUMMY_UAID, &rec.channel_id)?.is_none());
-        assert!(db.get_record(DUMMY_UAID, &rec.channel_id)?.is_none());
-        assert!(db.get_meta("uaid")?.is_none());
-        assert!(db.get_meta("auth")?.is_none());
+        assert!(db.get_record(&rec.channel_id)?.is_none());
+        assert!(db.get_record(&rec2.channel_id)?.is_some());
+        db.delete_all_records()?;
+        assert!(db.get_record(&rec.channel_id)?.is_none());
+        assert!(db.get_record(&rec.channel_id)?.is_none());
+        assert!(db.get_uaid()?.is_none());
+        assert!(db.get_auth()?.is_none());
         Ok(())
     }
 
@@ -324,12 +355,12 @@ mod test {
     fn meta() -> Result<()> {
         use super::Storage;
         let db = get_db()?;
-        let no_rec = db.get_meta("uaid")?;
+        let no_rec = db.get_uaid()?;
         assert_eq!(no_rec, None);
-        db.set_meta("uaid", DUMMY_UAID)?;
+        db.set_uaid(DUMMY_UAID)?;
         db.set_meta("fruit", "apple")?;
         db.set_meta("fruit", "banana")?;
-        assert_eq!(db.get_meta("uaid")?, Some(DUMMY_UAID.to_owned()));
+        assert_eq!(db.get_uaid()?, Some(DUMMY_UAID.to_owned()));
         assert_eq!(db.get_meta("fruit")?, Some("banana".to_owned()));
         Ok(())
     }
@@ -342,8 +373,8 @@ mod test {
         let rec = prec(chid);
 
         assert!(db.put_record(&rec)?);
-        assert!(db.get_record(DUMMY_UAID, chid)?.is_some());
-        assert!(db.delete_record(DUMMY_UAID, chid)?);
+        assert!(db.get_record(chid)?.is_some());
+        assert!(db.delete_record(chid)?);
         Ok(())
     }
 }
diff --git a/components/push/src/internal/storage/record.rs b/components/push/src/internal/storage/record.rs
index 4a6fb9639d..ec087e8ad1 100644
--- a/components/push/src/internal/storage/record.rs
+++ b/components/push/src/internal/storage/record.rs
@@ -11,22 +11,8 @@ use super::types::Timestamp;
 
 pub type ChannelID = String;
 
-/// Meta information are various push related values that need to persist across restarts.
-/// e.g. "UAID", server "auth" token, etc. This table should not be exposed outside of
-/// the push component.
-#[derive(Clone, Debug, PartialEq)]
-pub struct MetaRecord {
-    /// User Agent unique identifier
-    pub key: String,
-    /// Server authorization token
-    pub val: String,
-}
-
 #[derive(Clone, Debug, PartialEq)]
 pub struct PushRecord {
-    /// User Agent's unique identifier
-    pub uaid: String,
-
     /// Designation label provided by the subscribing service
     pub channel_id: ChannelID,
 
@@ -45,38 +31,31 @@ pub struct PushRecord {
     /// VAPID public key to restrict subscription updates for only those that sign
     /// using the private VAPID key.
     pub app_server_key: Option<String>,
-
-    /// (if this is a bridged connection (e.g. on Android), this is the native OS Push ID)
-    pub native_id: Option<String>,
 }
 
 impl PushRecord {
     /// Create a Push Record from the Subscription info: endpoint, encryption
     /// keys, etc.
-    pub fn new(uaid: &str, chid: &str, endpoint: &str, scope: &str, key: Key) -> Self {
+    pub fn new(chid: &str, endpoint: &str, scope: &str, key: Key) -> Self {
         // XXX: unwrap
         Self {
-            uaid: uaid.to_owned(),
             channel_id: chid.to_owned(),
             endpoint: endpoint.to_owned(),
             scope: scope.to_owned(),
             key: key.serialize().unwrap(),
             ctime: Timestamp::now(),
             app_server_key: None,
-            native_id: None,
         }
     }
 
     pub(crate) fn from_row(row: &Row<'_>) -> Result<Self> {
         Ok(PushRecord {
-            uaid: row.get("uaid")?,
             channel_id: row.get("channel_id")?,
             endpoint: row.get("endpoint")?,
             scope: row.get("scope")?,
             key: row.get("key")?,
             ctime: row.get("ctime")?,
             app_server_key: row.get("app_server_key")?,
-            native_id: row.get("native_id")?,
         })
     }
 }
diff --git a/components/push/src/internal/storage/schema.rs b/components/push/src/internal/storage/schema.rs
index 9db95714fa..1c1b4e9446 100644
--- a/components/push/src/internal/storage/schema.rs
+++ b/components/push/src/internal/storage/schema.rs
@@ -10,7 +10,7 @@ pub struct PushConnectionInitializer;
 
 impl open_database::ConnectionInitializer for PushConnectionInitializer {
     const NAME: &'static str = "push db";
-    const END_VERSION: u32 = 2;
+    const END_VERSION: u32 = 3;
 
     // This is such a simple database that we do almost nothing!
     // * We have no foreign keys, so `PRAGMA foreign_keys = ON;` is pointless.
@@ -30,6 +30,25 @@ impl open_database::ConnectionInitializer for PushConnectionInitializer {
         match version {
             0 => db.execute_batch(CREATE_TABLE_PUSH_SQL)?,
             1 => db.execute_batch(CREATE_TABLE_PUSH_SQL)?,
+            2 => {
+                // We dropped the `uaid` and `native_id` columns and added a constraint that scope
+                // must not be an empty string and must be unique.
+                let sql = format!(
+                    "
+                    -- rename the old table.
+                    ALTER TABLE push_record RENAME TO push_record_old;
+                    -- create the new table with the new schema.
+                    {CREATE_TABLE_PUSH_SQL};
+                    -- move the data across.
+                    INSERT OR IGNORE INTO push_record ({COMMON_COLS})
+                    SELECT {COMMON_COLS} FROM push_record_old WHERE length(scope) > 0;
+                    -- drop the old table
+                    DROP TABLE push_record_old;",
+                    CREATE_TABLE_PUSH_SQL = CREATE_TABLE_PUSH_SQL,
+                    COMMON_COLS = COMMON_COLS,
+                );
+                db.execute_batch(&sql)?;
+            }
             other => {
                 log::warn!(
                     "Loaded future schema version {} (we only understand version {}). \
@@ -44,12 +63,83 @@ impl open_database::ConnectionInitializer for PushConnectionInitializer {
 }
 
 pub const COMMON_COLS: &str = "
-    uaid,
     channel_id,
     endpoint,
     scope,
     key,
     ctime,
-    app_server_key,
-    native_id
+    app_server_key
 ";
+
+#[cfg(test)]
+mod test {
+    use tempfile::TempDir;
+
+    use crate::internal::storage::db::{PushDb, Storage};
+    use rusqlite::{Connection, OpenFlags};
+    use sql_support::ConnExt;
+
+    const CREATE_V2_SCHEMA: &str = include_str!("test/schema_v2.sql");
+
+    #[test]
+    fn test_migrate_v2_v3() {
+        env_logger::try_init().ok();
+        let tempdir = TempDir::new().unwrap();
+        let path = tempdir.path().join("push_v2.sql");
+
+        let conn = Connection::open_with_flags(path.clone(), OpenFlags::default()).unwrap();
+        conn.execute_batch(CREATE_V2_SCHEMA).unwrap();
+
+        // insert some stuff
+        conn.execute_batch(
+            r#"
+            INSERT INTO push_record (
+                uaid,    channel_id, endpoint, scope,  key,     ctime, app_server_key, native_id
+            ) VALUES
+                ("id-1", "cid1",     "ep-1",   "sc-1", x'1234', 1,    "ask-1",         "nid-1"),
+                -- duplicate scope, which isn't allowed in the new schema
+                ("id-2", "cid2",     "ep-2",   "sc-1", x'5678', 2,    "ask-2",         "nid-2"),
+                -- empty scope, which isn't allowed in the new schema
+                ("id-3", "cid3",     "ep-3",   "",     x'0000', 3,    "ask-3",         "nid-3")
+            ;
+            INSERT into meta_data (
+                key, value
+            ) VALUES
+                ("key-1", "value-1"),
+                ("key-2", "value-2")
+            "#,
+        )
+        .unwrap();
+
+        // reopen the database.
+        drop(conn);
+        let db = PushDb::open(path).expect("should open");
+
+        // Should only have 1 row in push_record
+        assert_eq!(
+            db.query_one::<u32>("SELECT COUNT(*) FROM push_record")
+                .unwrap(),
+            1
+        );
+        let record = db
+            .get_record("cid1")
+            .expect("should work")
+            .expect("should get a record");
+        assert_eq!(record.channel_id, "cid1");
+        assert_eq!(record.endpoint, "ep-1");
+        assert_eq!(record.scope, "sc-1");
+        assert_eq!(record.key, [0x12, 0x34]);
+        assert_eq!(record.ctime.0, 1);
+        assert_eq!(record.app_server_key.unwrap(), "ask-1");
+
+        // But both metadata ones.
+        assert_eq!(
+            db.db
+                .query_one::<u32>("SELECT COUNT(*) FROM meta_data")
+                .unwrap(),
+            2
+        );
+        assert_eq!(db.get_meta("key-1").unwrap().unwrap(), "value-1");
+        assert_eq!(db.get_meta("key-2").unwrap().unwrap(), "value-2");
+    }
+}
diff --git a/components/push/src/internal/storage/schema.sql b/components/push/src/internal/storage/schema.sql
index f6f5a08289..ed1c2d258c 100644
--- a/components/push/src/internal/storage/schema.sql
+++ b/components/push/src/internal/storage/schema.sql
@@ -5,15 +5,16 @@
 CREATE TABLE
 IF NOT EXISTS push_record
 (
-    uaid               TEXT     NOT NULL,
-    channel_id         TEXT     NOT NULL UNIQUE,
+    channel_id         TEXT     NOT NULL PRIMARY KEY,
+    -- `endpoint` must be unique; if 2 scopes ended up with the same endpoint, we'd possibly
+    -- end up with a push message sent to the wrong observer.
     endpoint           TEXT     NOT NULL UNIQUE,
-    scope              TEXT     NOT NULL,
+    scope              TEXT     NOT NULL UNIQUE,
     key                TEXT     NOT NULL,
     ctime              INTEGER  NOT NULL,
     app_server_key     TEXT,
-    native_id          TEXT,
-    PRIMARY KEY (uaid, channel_id)
+    -- scope must have a value!
+    CHECK(length(scope) > 0)
 );
 
 CREATE TABLE
diff --git a/components/push/src/internal/storage/test/schema_v2.sql b/components/push/src/internal/storage/test/schema_v2.sql
new file mode 100644
index 0000000000..f6f5a08289
--- /dev/null
+++ b/components/push/src/internal/storage/test/schema_v2.sql
@@ -0,0 +1,24 @@
+-- This Source Code Form is subject to the terms of the Mozilla Public
+-- License, v. 2.0. If a copy of the MPL was not distributed with this
+-- file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+CREATE TABLE
+IF NOT EXISTS push_record
+(
+    uaid               TEXT     NOT NULL,
+    channel_id         TEXT     NOT NULL UNIQUE,
+    endpoint           TEXT     NOT NULL UNIQUE,
+    scope              TEXT     NOT NULL,
+    key                TEXT     NOT NULL,
+    ctime              INTEGER  NOT NULL,
+    app_server_key     TEXT,
+    native_id          TEXT,
+    PRIMARY KEY (uaid, channel_id)
+);
+
+CREATE TABLE
+IF NOT EXISTS meta_data
+(
+    key                TEXT    PRIMARY KEY,
+    value                      NOT NULL
+) without ROWID;
diff --git a/components/push/src/internal/subscriber.rs b/components/push/src/internal/subscriber.rs
index f8408188ed..572c1058c6 100644
--- a/components/push/src/internal/subscriber.rs
+++ b/components/push/src/internal/subscriber.rs
@@ -53,7 +53,6 @@ impl From<PushRecord> for PushSubscriptionChanged {
 impl From<PushRecord> for DispatchInfo {
     fn from(record: PushRecord) -> Self {
         DispatchInfo {
-            uaid: record.uaid,
             scope: record.scope,
             endpoint: record.endpoint,
             app_server_key: record.app_server_key,
@@ -63,7 +62,6 @@ impl From<PushRecord> for DispatchInfo {
 
 pub struct PushManager {
     config: PushConfiguration,
-    pub conn: ConnectHttp,
     pub store: Store,
     update_rate_limiter: PersistedRateLimiter,
 }
@@ -75,10 +73,8 @@ impl PushManager {
         } else {
             Store::open_in_memory()?
         };
-        let uaid = store.get_meta("uaid")?;
         Ok(Self {
-            config: config.clone(),
-            conn: connect(config, uaid, store.get_meta("auth")?)?,
+            config,
             store,
             update_rate_limiter: PersistedRateLimiter::new(
                 "update_token",
@@ -88,6 +84,12 @@ impl PushManager {
         })
     }
 
+    pub fn make_connection(&self) -> Result<ConnectHttp> {
+        let uaid = self.store.get_uaid()?;
+        let auth = self.store.get_auth()?;
+        let reg_id = self.store.get_registration_id()?;
+        connect(self.config.clone(), uaid, auth, reg_id)
+    }
     // XXX: make these trait methods
     pub fn subscribe(
         &mut self,
@@ -102,102 +104,136 @@ impl PushManager {
         } else {
             server_key
         };
-        let reg_token = self.config.registration_id.clone().unwrap();
-        let subscription_key: Key;
-        if let Some(uaid) = self.conn.uaid.clone() {
-            // Don't fetch the connection from the server if we've already got one.
-            if let Some(record) = self.store.get_record(&uaid, channel_id)? {
-                return Ok((
-                    RegisterResponse {
-                        uaid,
-                        channel_id: record.channel_id,
-                        endpoint: record.endpoint,
-                        secret: self.store.get_meta("auth")?,
-                        senderid: Some(reg_token),
-                    },
-                    Key::deserialize(&record.key)?,
-                )
-                    .into());
-            }
+        // Don't fetch the subscription from the server if we've already got one.
+        if let Some(record) = self.store.get_record(channel_id)? {
+            let uaid = self.store.get_uaid()?.ok_or_else(|| {
+                // should be impossible - we should delete all records when we lose our uiad.
+                ErrorKind::StorageError("DB has a subscription but no UAID".to_string())
+            })?;
+            log::debug!("returning existing subscription for '{}'", scope);
+            return Ok((
+                RegisterResponse {
+                    uaid,
+                    channel_id: record.channel_id,
+                    endpoint: record.endpoint,
+                    secret: self.store.get_auth()?,
+                },
+                Key::deserialize(&record.key)?,
+            )
+                .into());
+        }
+
+        let mut conn = self.make_connection()?;
+        let info = conn.subscribe(channel_id, server_key)?;
+        log::debug!("server returned subscription info: {:?}", info);
+        // If our uaid has changed, or this is the first subscription we have made, all existing
+        // records must die - but we can keep this one!
+        let is_new_uaid = match self.store.get_uaid()? {
+            Some(old_uaid) => old_uaid != info.uaid,
+            None => true,
+        };
+        if is_new_uaid {
+            // apparently the uaid changing but not getting a new secret guarantees we will be
+            // unable to decrypt payloads. This should be impossible, so we could argue an
+            // assertion makes more sense so it makes unmistakable noise, but for now we just Err.
+            let new_auth = match info.secret {
+                Some(ref secret) => secret,
+                None => {
+                    return Err(ErrorKind::GeneralError(
+                        "Server gave us a new uaid but no secret?".to_string(),
+                    )
+                    .into())
+                }
+            };
+            log::info!(
+                "Got new new UAID of '{}' - deleting all existing records",
+                info.uaid
+            );
+            self.store.delete_all_records()?;
+            self.store.set_uaid(&info.uaid)?;
+            self.store.set_auth(new_auth)?;
         }
-        let info = self.conn.subscribe(channel_id, server_key)?;
-        if &self.config.sender_id == "test" {
-            subscription_key = Crypto::test_key(
+        // store the channel_id => auth + subscription_key
+        let subscription_key = if &self.config.sender_id == "test" {
+            Crypto::test_key(
                 "qJkxxWGVVxy7BKvraNY3hg8Gs-Y8qi0lRaXWJ3R3aJ8",
                 "BBcJdfs1GtMyymFTtty6lIGWRFXrEtJP40Df0gOvRDR4D8CKVgqE6vlYR7tCYksIRdKD1MxDPhQVmKLnzuife50",
                 "LsuUOBKVQRY6-l7_Ajo-Ag"
             )
         } else {
-            subscription_key = Crypto::generate_key()?;
-        }
-        // store the channel_id => auth + subscription_key
+            Crypto::generate_key()?
+        };
         let mut record = crate::internal::storage::PushRecord::new(
-            &info.uaid,
             &info.channel_id,
             &info.endpoint,
             scope,
             subscription_key.clone(),
         );
         record.app_server_key = server_key.map(|v| v.to_owned());
-        record.native_id = Some(reg_token);
         self.store.put_record(&record)?;
-        // store the meta information if we've not yet done that.
-        if self.store.get_meta("uaid")?.is_none() {
-            self.store.set_meta("uaid", &info.uaid)?;
-            if let Some(secret) = &info.secret {
-                self.store.set_meta("auth", secret)?;
-            }
-        }
+        log::debug!("subscribed OK");
         Ok((info, subscription_key).into())
     }
 
     pub fn unsubscribe(&mut self, channel_id: &str) -> Result<bool> {
         // TODO(teshaq): This should throw an error instead of return false
         // keeping this as false in the meantime while uniffing to not change behavior
+        // markh: both branches below are broken in our v3 schema - someone may have subscribed,
+        // we then discover the server lost our subs (causing us to delete the world), and the
+        // consumer then tries to unsubscribe. The consumer hasn't done anything wrong! We should
+        // store "requested subscriptions" separately from "actual subscriptions" and this dilemma
+        // would go away - it's an error to unsubscribe from something never subscribed to, but
+        // not because we lost it!
         if channel_id.is_empty() {
             return Ok(false);
         }
-        if self.conn.uaid.is_none() {
+        let conn = self.make_connection()?;
+        if conn.uaid.is_none() {
             return Err(ErrorKind::GeneralError("No subscriptions created yet.".into()).into());
         }
-        self.conn.unsubscribe(channel_id)?;
-        self.store
-            .delete_record(self.conn.uaid.as_ref().unwrap(), channel_id)
+        conn.unsubscribe(channel_id)?;
+        self.store.delete_record(channel_id)
     }
 
     pub fn unsubscribe_all(&mut self) -> Result<()> {
-        if self.conn.uaid.is_none() {
-            return Err(ErrorKind::GeneralError("No subscriptions created yet.".into()).into());
-        }
-        let uaid = self.conn.uaid.as_ref().unwrap();
-        self.store.delete_all_records(uaid)?;
-        self.conn.unsubscribe_all()?;
+        // make connection before deleting, because deletion kills our uaid/auth meta.
+        let mut conn = self.make_connection()?;
+        self.store.delete_all_records()?;
+        conn.unsubscribe_all()?;
         Ok(())
     }
 
     pub fn update(&mut self, new_token: &str) -> error::Result<bool> {
-        if self.conn.uaid.is_none() {
-            return Err(ErrorKind::GeneralError("No subscriptions created yet.".into()).into());
+        self.store.set_registration_id(new_token)?;
+        let mut conn = self.make_connection()?;
+        // It's OK if we don't have a uaid yet - that means we can't have any subscriptions,
+        // and we've saved our registration_id, so will use it on our first subscription.
+        if conn.uaid.is_none() {
+            log::info!(
+                "saved the registration ID but not telling the server as we have no subs yet"
+            );
+            return Ok(false);
         }
         if !self.update_rate_limiter.check(&self.store) {
             return Ok(false);
         }
-        self.conn.update(new_token)?;
-        self.store
-            .update_native_id(self.conn.uaid.as_ref().unwrap(), new_token)?;
+        if let Err(e) = conn.update(new_token) {
+            match e.kind() {
+                ErrorKind::UAIDNotRecognizedError(_) => {
+                    // Our subscriptions are dead, but for now, just let the existing mechanisms
+                    // deal with that (eg, next `subscribe()` or `verify_connection()`)
+                    log::info!("updating our token indicated our subscriptions are gone");
+                }
+                _ => return Err(e),
+            }
+        }
         Ok(true)
     }
 
     pub fn verify_connection(&mut self) -> Result<Vec<PushSubscriptionChanged>> {
-        let uaid = self
-            .conn
-            .uaid
-            .as_ref()
-            .ok_or_else(|| ErrorKind::GeneralError("No subscriptions created yet.".into()))?
-            .to_owned();
-
-        let channels = self.store.get_channel_list(&uaid)?;
-        if self.conn.verify_connection(&channels)? {
+        let mut conn = self.make_connection()?;
+        let channels = self.store.get_channel_list()?;
+        if conn.verify_connection(&channels)? {
             // Everything is fine, our subscriptions in the db match the remote server.
             return Ok(Vec::new());
         }
@@ -208,12 +244,9 @@ impl PushManager {
                 subscriptions.push(record.into());
             }
         }
-        // we wipe the UAID if there is a mismatch, forcing us to later
-        // re-generate a new one when we do the next first subscription.
-        // this is to prevent us from attempting to communicate with the server using an outdated
-        // UAID, the in-memory uaid was already wiped in the `verify_connection` call
-        // when we unsubscribe
-        self.store.delete_all_records(&uaid)?;
+        // we wipe all existing subscriptions and the UAID if there is a mismatch; the next
+        // `subscribe()` call will get a new UAID.
+        self.store.delete_all_records()?;
         Ok(subscriptions)
     }
 
@@ -225,15 +258,11 @@ impl PushManager {
         salt: Option<&str>,
         dh: Option<&str>,
     ) -> Result<Vec<u8>> {
-        if self.conn.uaid.is_none() {
-            return Err(ErrorKind::GeneralError("No subscriptions created yet.".into()).into());
-        }
-        let uaid = self.conn.uaid.as_ref().unwrap();
         let val = self
             .store
-            .get_record(uaid, chid)
+            .get_record(chid)
             .map_err(|e| ErrorKind::StorageError(format!("{:?}", e)))?
-            .ok_or_else(|| ErrorKind::RecordNotFoundError(uaid.to_owned(), chid.to_owned()))?;
+            .ok_or_else(|| ErrorKind::RecordNotFoundError(chid.to_owned()))?;
         let key = Key::deserialize(&val.key)?;
         Crypto::decrypt(&key, body, encoding, salt, dh)
             .map_err(|e| ErrorKind::CryptoError(format!("{:?}", e)).into())
@@ -248,19 +277,25 @@ impl PushManager {
 mod test {
     use super::*;
     const TEST_CHANNEL_ID: &str = "deadbeef00000000decafbad00000000";
-    #[test]
-    fn basic() -> Result<()> {
+
+    fn get_test_manager() -> Result<PushManager> {
         let test_config = PushConfiguration {
             sender_id: "test".to_owned(),
             ..Default::default()
         };
-        let mut pm = PushManager::new(test_config)?;
-        let resp = pm.subscribe(TEST_CHANNEL_ID, "", None)?;
+        let pm = PushManager::new(test_config)?;
+        pm.store.set_registration_id("native-id")?;
+        Ok(pm)
+    }
+    #[test]
+    fn basic() -> Result<()> {
+        let mut pm = get_test_manager()?;
+        let resp = pm.subscribe(TEST_CHANNEL_ID, "test-scope", None)?;
         // verify that a subsequent request for the same channel ID returns the same subscription
-        let resp2 = pm.subscribe(TEST_CHANNEL_ID, "", None)?;
+        let resp2 = pm.subscribe(TEST_CHANNEL_ID, "test-scope", None)?;
         assert_eq!(
             Some("LsuUOBKVQRY6-l7_Ajo-Ag".to_owned()),
-            pm.store.get_meta("auth")?
+            pm.store.get_auth()?
         );
         assert_eq!(
             resp.subscription_info.endpoint,
@@ -279,13 +314,8 @@ mod test {
         use rc_crypto::ece;
         rc_crypto::ensure_initialized();
         let data_string = b"Mary had a little lamb, with some nice mint jelly";
-        let test_config = PushConfiguration {
-            sender_id: "test".to_owned(),
-            // database_path: Some("test.db"),
-            ..Default::default()
-        };
-        let mut pm = PushManager::new(test_config)?;
-        let resp = pm.subscribe(TEST_CHANNEL_ID, "", None)?;
+        let mut pm = get_test_manager()?;
+        let resp = pm.subscribe(TEST_CHANNEL_ID, "test-scope", None)?;
         let key_info = resp.subscription_info.keys;
         let remote_pub = base64::decode_config(&key_info.p256dh, base64::URL_SAFE_NO_PAD).unwrap();
         let auth = base64::decode_config(&key_info.auth, base64::URL_SAFE_NO_PAD).unwrap();
@@ -305,20 +335,16 @@ mod test {
 
     #[test]
     fn test_wipe_uaid() -> Result<()> {
-        let test_config = PushConfiguration {
-            sender_id: "test".to_owned(),
-            ..Default::default()
-        };
-        let mut pm = PushManager::new(test_config)?;
-        let _ = pm.subscribe(TEST_CHANNEL_ID, "", None)?;
+        let mut pm = get_test_manager()?;
+        let _ = pm.subscribe(TEST_CHANNEL_ID, "test-scope", None)?;
         // verify that a uaid got added to our store and
         // that there is a record associated with the channel ID provided
-        let uaid = pm.store.get_meta("uaid")?.unwrap();
         assert_eq!(
-            pm.store
-                .get_record(&uaid, TEST_CHANNEL_ID)?
-                .unwrap()
-                .channel_id,
+            pm.store.get_uaid()?.unwrap(),
+            "abad1d3a00000000aabbccdd00000000"
+        );
+        assert_eq!(
+            pm.store.get_record(TEST_CHANNEL_ID)?.unwrap().channel_id,
             TEST_CHANNEL_ID
         );
         let unsubscribed_channels = pm.verify_connection()?;
@@ -326,20 +352,20 @@ mod test {
         assert_eq!(unsubscribed_channels[0].channel_id, TEST_CHANNEL_ID);
         // since verify_connection failed,
         // we wipe the uaid and all associated records from our store
-        assert!(pm.store.get_meta("uaid")?.is_none());
-        assert!(pm.store.get_record(&uaid, TEST_CHANNEL_ID)?.is_none());
+        assert!(pm.store.get_uaid()?.is_none());
+        assert!(pm.store.get_record(TEST_CHANNEL_ID)?.is_none());
 
         // we now check that a new subscription will cause us to
         // re-generate a uaid and store it in our store
-        let _ = pm.subscribe(TEST_CHANNEL_ID, "", None)?;
+        let _ = pm.subscribe(TEST_CHANNEL_ID, "test-scope", None)?;
         // verify that the uaid got added to our store and
         // that there is a record associated with the channel ID provided
-        let uaid = pm.store.get_meta("uaid")?.unwrap();
         assert_eq!(
-            pm.store
-                .get_record(&uaid, TEST_CHANNEL_ID)?
-                .unwrap()
-                .channel_id,
+            pm.store.get_uaid()?.unwrap(),
+            "abad1d3a00000000aabbccdd00000000"
+        );
+        assert_eq!(
+            pm.store.get_record(TEST_CHANNEL_ID)?.unwrap().channel_id,
             TEST_CHANNEL_ID
         );
         Ok(())
diff --git a/components/push/src/lib.rs b/components/push/src/lib.rs
index 11c516d154..86c5da9b6a 100644
--- a/components/push/src/lib.rs
+++ b/components/push/src/lib.rs
@@ -191,6 +191,7 @@ pub use crate::internal::error::*;
 pub use internal::communications::Connection;
 pub use internal::crypto::get_random_bytes;
 pub use internal::error::Result as InternalResult;
+pub use internal::storage::Storage as InternalStorage;
 pub use internal::PushConfiguration;
 pub use internal::PushManager as InternalPushManager;
 // =====================
@@ -241,11 +242,16 @@ impl PushManager {
             BridgeType::Test => "test",
         }
         .to_string();
+        if !registration_id.is_empty() {
+            log::warn!("`registration_id` is ignored/deprecated when creating a push manager.");
+        }
+        // XXX - we probably should persist, say, this as JSON and ensure it's the same
+        // on each run, then nuke the DB if not. Eg, imagine "bridge_type" changing, things
+        // would break badly. Unlikely, so later...
         let config = PushConfiguration {
             server_host,
             http_protocol: Some(http_protocol),
             bridge_type: Some(bridge_type),
-            registration_id: Some(registration_id),
             sender_id,
             database_path: Some(database_path),
             ..Default::default()
@@ -441,8 +447,8 @@ pub enum PushError {
     #[error("Storage Error: {0:?}")]
     StorageError(String),
 
-    #[error("No record for uaid:chid {0:?}:{1:?}")]
-    RecordNotFoundError(String, String),
+    #[error("No record for chid {0:?}")]
+    RecordNotFoundError(String),
 
     /// A failure to encode data to/from storage.
     #[error("Error executing SQL: {0}")]
@@ -509,9 +515,7 @@ impl From<internal::error::Error> for PushError {
             }
             ErrorKind::AlreadyRegisteredError => PushError::AlreadyRegisteredError,
             ErrorKind::StorageError(message) => PushError::StorageError(message.clone()),
-            ErrorKind::RecordNotFoundError(uaid, chid) => {
-                PushError::RecordNotFoundError(uaid.clone(), chid.clone())
-            }
+            ErrorKind::RecordNotFoundError(chid) => PushError::RecordNotFoundError(chid.clone()),
             ErrorKind::StorageSqlError(e) => PushError::StorageSqlError(e.to_string()),
             ErrorKind::MissingRegistrationTokenError => PushError::MissingRegistrationTokenError,
             ErrorKind::TranscodingError(message) => PushError::TranscodingError(message.clone()),
@@ -529,7 +533,6 @@ impl From<internal::error::Error> for PushError {
 /// Dispatch Information returned from [`PushManager::dispatch_info_for_chid`]
 #[derive(Debug, Clone, PartialEq)]
 pub struct DispatchInfo {
-    pub uaid: String,
     pub scope: String,
     pub endpoint: String,
     pub app_server_key: Option<String>,
diff --git a/components/push/src/push.udl b/components/push/src/push.udl
index dd05d37d50..ba0c1705ae 100644
--- a/components/push/src/push.udl
+++ b/components/push/src/push.udl
@@ -20,7 +20,7 @@ interface PushManager {
     //   - `server_host` - The host name for the service (e.g. "updates.push.services.mozilla.com").
     //   - `http_protocol` - The optional socket protocol (default: "https")
     //   - `bridge_type` - The [`BridgeType`] the consumer would like to use to deliver the push messages
-    //   - `registration_id` - The native OS messaging registration ID
+    //   - `registration_id` - NOT USED. REMOVE ME.
     //   - `database_path` - The path where [`PushManager`] will store persisted state
     //
     // # Errors
@@ -28,7 +28,7 @@ interface PushManager {
     //   - PushManager is unable to open the `database_path` given
     //   - PushManager is unable to establish a connection to the autopush server
     [Throws=PushError]
-    constructor(string sender_id, optional string server_host = "updates.push.services.mozilla.com", optional string http_protocol = "https", BridgeType bridge_type, string registration_id, optional string database_path = "push.sqlite");
+    constructor(string sender_id, optional string server_host = "updates.push.services.mozilla.com", optional string http_protocol = "https", BridgeType bridge_type, optional string registration_id = "", optional string database_path = "push.sqlite");
 
     // Subscribes to a new channel and gets the Subscription Info block
     //
@@ -78,14 +78,19 @@ interface PushManager {
     void unsubscribe_all();
 
     // Updates the Native OS push registration ID.
-    // **NOTE**: If this returns false, the subsequent [`PushManager::verify_connection`]
-    // may result in new endpoint registration
+    // **NOTE**: If this returns false, it means we were rate limited!
+    // XXX - this concept needs love - this was originally documented as:
+    // > If this returns false, the subsequent [`PushManager::verify_connection`]
+    // > may result in new endpoint registration
+    // Long story short, there's no way to know that this `update()` call thinks all our
+    // subscriptions need renewal, but we instead rely on `verify_connection()` being
+    // called regularly for this purpose.
     //
     // # Arguments:
     //   - `new_token` - the new Native OS push registration ID
     //
     // # Returns
-    // Returns a boolean indicating if the update was successful
+    // Returns a boolean indicating if tried to tell the server about it.
     //
     // # Errors
     // Return an error in the following cases:
@@ -154,7 +159,6 @@ interface PushManager {
 
 // Dispatch Information returned from [`PushManager::dispatch_info_for_chid`]
 dictionary DispatchInfo {
-    string uaid;
     string scope;
     string endpoint;
     string? app_server_key;
diff --git a/examples/push-livetest/src/livetest.rs b/examples/push-livetest/src/livetest.rs
index 70427ea83f..185a674dc4 100644
--- a/examples/push-livetest/src/livetest.rs
+++ b/examples/push-livetest/src/livetest.rs
@@ -6,6 +6,7 @@ use push::get_random_bytes;
 use push::Connection;
 use push::InternalPushManager as PushManager;
 use push::InternalResult as Result;
+use push::InternalStorage;
 use push::PushConfiguration;
 
 /** Perform a "Live" test against a locally configured push server
@@ -37,7 +38,6 @@ fn test_live_server() -> Result<()> {
         server_host: "localhost:8082".to_owned(),
         sender_id: "fir-bridgetest".to_owned(),
         bridge_type: Some("fcm".to_owned()),
-        registration_id: Some("SomeRegistrationValue".to_owned()),
         ..Default::default()
     };
     let mut pm = PushManager::new(config)?;
@@ -49,7 +49,10 @@ fn test_live_server() -> Result<()> {
     println!("\n == Subscribing channels");
     let sub1 = pm.subscribe(&channel1, "", None).expect("subscribe failed");
     // These are normally opaque values, displayed here for debug.
-    println!("Connection info: {:?}", (&pm.conn.uaid, &pm.conn.auth));
+    println!(
+        "Connection info: {:?}",
+        (&pm.store.get_uaid()?, &pm.store.get_auth()?)
+    );
     println!("## Subscription 1: {:?}", sub1);
     println!("## Info: {:?}", pm.get_record_by_chid(&channel1));
     let sub2 = pm.subscribe(&channel2, "", None)?;
@@ -58,13 +61,15 @@ fn test_live_server() -> Result<()> {
     // You don't need to do this, normally. This is just for
     // debugging and analysis.
     println!("\n == Fetching channel list 1");
-    let ll = pm.conn.channel_list().expect("channel list failed");
+    let conn = pm.make_connection()?;
+    let ll = conn.channel_list().expect("channel list failed");
     println!("Server Known channels: {:?}", ll);
 
     println!("\n == Unsubscribing single channel");
     pm.unsubscribe(&channel1).expect("chid unsub failed");
     println!("\n == Fetching channel list 2");
-    let ll = pm.conn.channel_list().expect("channel list failed");
+    let conn = pm.make_connection()?;
+    let ll = conn.channel_list().expect("channel list failed");
     println!("Server Known channels: {:?}", ll);
 
     // the list of known channels should come from whatever is
@@ -72,7 +77,8 @@ fn test_live_server() -> Result<()> {
     println!("Verify: {:?}", pm.verify_connection());
 
     println!("\n == Fetching channel list 3");
-    let ll = pm.conn.channel_list().expect("channel list failed");
+    let conn = pm.make_connection()?;
+    let ll = conn.channel_list().expect("channel list failed");
     println!("Server Known channels: {:?}", ll);
 
     println!("\n == Unsubscribing all.");