Get bucket reachability credential with bucket, not level up

src/lib.rs

@@ -1,5 +1,6 @@
 use lox_library::{
     bridge_table::{from_scalar, BridgeLine, BridgeTable, EncryptedBucket, MAX_BRIDGES_PER_BUCKET},
+    cred,
     proto::{
         level_up::{LEVEL_INTERVAL, MAX_BLOCKAGES},
         *,
@@ -86,14 +87,17 @@ pub async fn get_reachability_credential(net: &dyn Networking) -> HashMap<u32, E
 pub async fn get_bucket(
     net: &dyn Networking,
     lox_cred: &lox_library::cred::Lox,
-) -> [BridgeLine; MAX_BRIDGES_PER_BUCKET] {
+) -> (
+    [BridgeLine; MAX_BRIDGES_PER_BUCKET],
+    Option<cred::BucketReachability>,
+) {
     let encbuckets = get_reachability_credential(net).await;
     let (id, key) = from_scalar(lox_cred.bucket).unwrap();
     let encbucket = match encbuckets.get(&id) {
         Some(encbucket) => encbucket,
         None => panic!("Provided ID not found"),
     };
-    BridgeTable::decrypt_bucket(id, &key, &encbucket).unwrap().0
+    BridgeTable::decrypt_bucket(id, &key, &encbucket).unwrap()
 }
 
 // Get an open invitation
@@ -152,18 +156,10 @@ pub async fn trust_migration(
 pub async fn level_up(
     net: &dyn Networking,
     lox_cred: &lox_library::cred::Lox,
-    encbuckets: &HashMap<u32, EncryptedBucket>,
+    reachcred: &cred::BucketReachability,
     lox_pub: &IssuerPubKey,
     reachability_pub: &IssuerPubKey,
-) -> (lox_library::cred::Lox, [BridgeLine; MAX_BRIDGES_PER_BUCKET]) {
-    // Read the bucket in the credential to get today's Bucket
-    // Reachability credential
-    let (id, key) = from_scalar(lox_cred.bucket).unwrap();
-    let bucket = BridgeTable::decrypt_bucket(id, &key, &encbuckets.get(&id).unwrap()).unwrap();
-    let reachcred = bucket.1.unwrap();
-
-    // Use the Bucket Reachability credential to advance to the next
-    // level
+) -> lox_library::cred::Lox {
     let (req, state) = level_up::request(
         lox_cred,
         &reachcred,
@@ -176,12 +172,7 @@ pub async fn level_up(
     let encoded_resp = net.request("/levelup".to_string(), encoded_req).await;
     let decoded_resp: level_up::Response = serde_json::from_slice(&encoded_resp).unwrap();
     let cred = level_up::handle_response(state, decoded_resp, lox_pub).unwrap();
-
-    // Get bucket
-    let (id, key) = from_scalar(lox_cred.bucket).unwrap();
-    let bucket = BridgeTable::decrypt_bucket(id, &key, &encbuckets.get(&id).unwrap()).unwrap();
-
-    (cred, bucket.0)
+    cred
 }
 
 // Request an Invitation credential to give to a friend
@@ -230,7 +221,7 @@ pub async fn redeem_invite(
     let decoded_resp: redeem_invite::Response = serde_json::from_slice(&encoded_resp).unwrap();
     let cred = redeem_invite::handle_response(state, decoded_resp, lox_pub).unwrap();
 
-    let bucket = get_bucket(net, &cred).await;
+    let bucket = get_bucket(net, &cred).await.0;
     (cred, bucket)
 }
 

src/main.rs

@@ -136,22 +136,23 @@ async fn main() {
                     get_migration_pub(&lox_auth_pubkeys),
                 )
                 .await;
-                let bucket = get_bucket(&net, &cred).await;
+                let bucket = get_bucket(&net, &cred).await.0;
                 (cred, bucket)
             } else {
                 (lox_cred, bucket)
             }
         } else {
             if eligible_for_level_up(&net, &lox_cred).await {
-                let encbuckets = get_reachability_credential(&net).await;
-                let (cred, bucket) = level_up(
+                let (bucket, reachcred) = get_bucket(&net, &lox_cred).await;
+                let cred = level_up(
                     &net,
                     &lox_cred,
-                    &encbuckets,
+                    &reachcred.unwrap(),
                     get_lox_pub(&lox_auth_pubkeys),
                     get_reachability_pub(&lox_auth_pubkeys),
                 )
                 .await;
+                let bucket = get_bucket(&net, &lox_cred).await.0;
                 (cred, bucket)
             } else {
                 (lox_cred, bucket)

src/tests.rs

@@ -55,17 +55,16 @@ pub async fn test_level_up(
     )
     .await;
     assert!(eligible_for_level_up(net, cred).await);
-    let encbuckets = get_reachability_credential(net).await;
+    let (bucket, reachcred) = get_bucket(net, cred).await;
     println!("Leveling up from level {} to {}", level, min(4, level + 1));
     let new_cred = level_up(
         net,
         cred,
-        &encbuckets,
+        &reachcred.unwrap(),
         get_lox_pub(la_pubkeys),
         get_reachability_pub(la_pubkeys),
     )
-    .await
-    .0;
+    .await;
     new_cred
 }
 
@@ -86,7 +85,7 @@ async fn test_credential_operations() {
     let open_inv = get_open_invitation(&net).await;
     let (mut cred, bridgeline) =
         get_lox_credential(&net, &open_inv, get_lox_pub(&la_pubkeys)).await;
-    let bucket = get_bucket(&net, &cred).await;
+    let bucket = get_bucket(&net, &cred).await.0;
 
     //assert_eq!(bucket[0], bridgeline); // For some reason, this sometimes fails.
     assert_eq!(bucket[1], BridgeLine::default());
@@ -116,20 +115,6 @@ async fn test_credential_operations() {
             scalar_u32(&cred.trust_level).unwrap(),
             u32::try_from(i).unwrap()
         );
-        /*
-                advance_days(&net_test, u16::try_from(LEVEL_INTERVAL[i]).unwrap()).await;
-                assert!(eligible_for_level_up(&net, &cred).await);
-                let encbuckets = get_reachability_credential(&net).await;
-                cred = level_up(
-                    &net,
-                    &cred,
-                    &encbuckets,
-                    get_lox_pub(&la_pubkeys),
-                    get_reachability_pub(&la_pubkeys),
-                )
-                .await
-                .0;
-        */
         cred = test_level_up(&net, &net_test, &cred, &la_pubkeys).await;
 
         // Assert that we increased level by 1 or stayed at 4
@@ -196,7 +181,7 @@ async fn test_credential_operations() {
 
     // Block 1 bridge
     println!("Marking one bridge blocked");
-    let bridges = get_bucket(&net, &cred).await;
+    let bridges = get_bucket(&net, &cred).await.0;
     let blocked_bridges = bridges_to_block(bridges, 1);
     let response = net_tp
         .request(
@@ -209,17 +194,14 @@ async fn test_credential_operations() {
     // Time passes...
     advance_days(&net_test, 1).await;
 
-    // Check that we still have a Bridge Reachability credential
-    let etable = get_reachability_credential(&net).await;
-    let (id, key) = from_scalar(cred.bucket).unwrap();
-    let encbucket = etable.get(&id).unwrap();
-    let bucket = BridgeTable::decrypt_bucket(id, &key, &encbucket).unwrap();
-    assert!(bucket.1.is_some());
-    println!("Can still obtain bridge reachability credential");
+    // Check that we still have a Bucket Reachability credential
+    let (bucket, reachcred) = get_bucket(&net, &cred).await;
+    assert!(reachcred.is_some());
+    println!("Can still obtain bucket reachability credential");
 
     // Block 2 bridges
     println!("Marking two bridges blocked");
-    let bridges = get_bucket(&net, &cred).await;
+    let bridges = get_bucket(&net, &cred).await.0;
     let blocked_bridges = bridges_to_block(bridges, 2);
     let response = net_tp
         .request(
@@ -232,13 +214,10 @@ async fn test_credential_operations() {
     // Time passes...
     advance_days(&net_test, 1).await;
 
-    // Check that we don't have a Bridge Reachability credential
-    let etable = get_reachability_credential(&net).await;
-    let (id, key) = from_scalar(cred.bucket).unwrap();
-    let encbucket = etable.get(&id).unwrap();
-    let bucket = BridgeTable::decrypt_bucket(id, &key, &encbucket).unwrap();
-    assert!(bucket.1.is_none());
-    println!("Cannot obtain bridge reachability credential");
+    // Check that we don't have a Bucket Reachability credential
+    let (bucket, reachcred) = get_bucket(&net, &cred).await;
+    assert!(reachcred.is_none());
+    println!("Cannot obtain bucket reachability credential");
 
     // Migrate to a new bucket
     println!("Migrating to a new bucket");
@@ -252,6 +231,7 @@ async fn test_credential_operations() {
     )
     .await;
     assert_eq!(scalar_u32(&cred.trust_level).unwrap(), 2);
+    assert_eq!(scalar_u32(&cred.blockages).unwrap(), 1);
 
     // TODO: Figure out why this always fails
     // Level up to level 3
@@ -262,7 +242,7 @@ async fn test_credential_operations() {
 
     // Another blockage happens
     println!("Marking three bridges blocked");
-    let bridges = get_bucket(&net, &cred).await;
+    let bridges = get_bucket(&net, &cred).await.0;
     let blocked_bridges = bridges_to_block(bridges, 3);
     let response = net_tp
         .request(