Get bucket during trust promotion or level up

src/client_lib.rs

@@ -75,8 +75,7 @@ pub async fn eligible_for_trust_promotion(
         None => return false,
     };
     get_cred_trust_level(cred) == 0
-        && level_since + lox_library::proto::trust_promotion::UNTRUSTED_INTERVAL
+        && level_since + trust_promotion::UNTRUSTED_INTERVAL <= get_today(net).await
-            <= get_today(net).await
 }
 
 // Helper function to check if credential is eligible for
@@ -186,16 +185,11 @@ pub async fn level_up(
     encbuckets: &HashMap<u32, EncryptedBucket>,
     lox_pub: &IssuerPubKey,
     reachability_pub: &IssuerPubKey,
-) -> lox_library::cred::Lox {
+) -> (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) = lox_library::bridge_table::from_scalar(lox_cred.bucket).unwrap();
+    let (id, key) = from_scalar(lox_cred.bucket).unwrap();
-    let bucket = lox_library::bridge_table::BridgeTable::decrypt_bucket(
+    let bucket = BridgeTable::decrypt_bucket(id, &key, &encbuckets.get(&id).unwrap()).unwrap();
-        id,
-        &key,
-        &encbuckets.get(&id).unwrap(),
-    )
-    .unwrap();
     let reachcred = bucket.1.unwrap();
 
     // Use the Bucket Reachability credential to advance to the next
@@ -212,7 +206,12 @@ 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();
-    cred
+
+    // 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)
 }
 
 // Request an Invitation credential to give to a friend
@@ -227,13 +226,8 @@ pub async fn issue_invite(
     // Read the bucket in the credential to get today's Bucket
     // Reachability credential
 
-    let (id, key) = lox_library::bridge_table::from_scalar(lox_cred.bucket).unwrap();
+    let (id, key) = from_scalar(lox_cred.bucket).unwrap();
-    let bucket = lox_library::bridge_table::BridgeTable::decrypt_bucket(
+    let bucket = BridgeTable::decrypt_bucket(id, &key, &encbuckets.get(&id).unwrap()).unwrap();
-        id,
-        &key,
-        &encbuckets.get(&id).unwrap(),
-    )
-    .unwrap();
     let reachcred = bucket.1.unwrap();
 
     let (req, state) = issue_invite::request(

src/main.rs

@@ -52,7 +52,7 @@ async fn main() {
     opts.optflag("I", "invite", "generate invitation for a friend");
     opts.optflag("L", "level-up", "increase trust level");
     opts.optflag("N", "new-lox-cred", "get a new Lox Credential");
-    opts.optflag("R", "redeem", "redeem invitation");
+    opts.optopt("R", "redeem", "redeem invitation", "INVITE_FILE");
     opts.optopt(
         "",
         "server",
@@ -145,11 +145,11 @@ async fn main() {
         (cred, bucket)
     };
 
-    let lox_cred = if matches.opt_present("L") {
+    let (lox_cred, bucket) = if matches.opt_present("L") {
         let old_level = get_cred_trust_level(&lox_cred);
 
         // If trust level is 0, do trust promotion, otherwise level up.
-        let cred = if old_level == 0 {
+        let (cred, bucket) = if old_level == 0 {
             if eligible_for_trust_promotion(&net, &lox_cred).await {
                 let migration_cred =
                     trust_promotion(&net, &lox_cred, get_lox_pub(&lox_auth_pubkeys)).await;
@@ -161,14 +161,15 @@ async fn main() {
                     get_migration_pub(&lox_auth_pubkeys),
                 )
                 .await;
-                cred
+                let bucket = get_bucket(&net, &cred).await;
+                (cred, bucket)
             } else {
-                lox_cred
+                (lox_cred, bucket)
             }
         } else {
             if eligible_for_level_up(&net, &lox_cred).await {
                 let encbuckets = get_reachability_credential(&net).await;
-                let cred = level_up(
+                let (cred, bucket) = level_up(
                     &net,
                     &lox_cred,
                     &encbuckets,
@@ -176,21 +177,22 @@ async fn main() {
                     get_reachability_pub(&lox_auth_pubkeys),
                 )
                 .await;
-                cred
+                (cred, bucket)
             } else {
-                lox_cred
+                (lox_cred, bucket)
             }
         };
         save_object(&cred, &lox_cred_filename);
+        save_object(&bucket, &bucket_filename);
         let new_level = get_cred_trust_level(&cred);
         if new_level > old_level {
             println!("Old level: {}\nNew level: {}", old_level, new_level);
         } else if new_level == old_level {
             println!("Unable to level up. Current level: {}", new_level);
         }
-        cred
+        (cred, bucket)
     } else {
-        lox_cred
+        (lox_cred, bucket)
     };
 
     // Invite a friend