[vouch] patch root trust score (#404)

Co-authored-by: Archibald MacRubato <[email protected]>
Co-authored-by: Sere Staccato <[email protected]>
Co-authored-by: Montague Legato <[email protected]>
Co-authored-by: xyz <xyz>
Co-authored-by: Gianna McAccelerando <[email protected]>

Author: 5 people

framework/cached-packages/src/libra_framework_sdk_builder.rs

@@ -115,6 +115,10 @@ pub enum EntryFunctionCall {
         cap_update_table: Vec<u8>,
     },
 
+    /// some accounts with transactions immediately after the v8 upgrade
+    /// may have a malformed timestamp
+    ActivityMaybeFixMalformed {},
+
     /// User opts into burns being sent to community (recycle burn).
     /// default is false (burn is final).
     BurnSetSendCommunity {
@@ -442,6 +446,7 @@ impl EntryFunctionCall {
                 new_public_key_bytes,
                 cap_update_table,
             ),
+            ActivityMaybeFixMalformed {} => activity_maybe_fix_malformed(),
             BurnSetSendCommunity { community } => burn_set_send_community(community),
             CodePublishPackageTxn {
                 metadata_serialized,
@@ -765,6 +770,23 @@ pub fn account_rotate_authentication_key_with_rotation_capability(
     ))
 }
 
+/// some accounts with transactions immediately after the v8 upgrade
+/// may have a malformed timestamp
+pub fn activity_maybe_fix_malformed() -> TransactionPayload {
+    TransactionPayload::EntryFunction(EntryFunction::new(
+        ModuleId::new(
+            AccountAddress::new([
+                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+                0, 0, 0, 1,
+            ]),
+            ident_str!("activity").to_owned(),
+        ),
+        ident_str!("maybe_fix_malformed").to_owned(),
+        vec![],
+        vec![],
+    ))
+}
+
 /// User opts into burns being sent to community (recycle burn).
 /// default is false (burn is final).
 pub fn burn_set_send_community(community: bool) -> TransactionPayload {
@@ -1696,6 +1718,14 @@ mod decoder {
         }
     }
 
+    pub fn activity_maybe_fix_malformed(payload: &TransactionPayload) -> Option<EntryFunctionCall> {
+        if let TransactionPayload::EntryFunction(_script) = payload {
+            Some(EntryFunctionCall::ActivityMaybeFixMalformed {})
+        } else {
+            None
+        }
+    }
+
     pub fn burn_set_send_community(payload: &TransactionPayload) -> Option<EntryFunctionCall> {
         if let TransactionPayload::EntryFunction(script) = payload {
             Some(EntryFunctionCall::BurnSetSendCommunity {
@@ -2230,6 +2260,10 @@ static SCRIPT_FUNCTION_DECODER_MAP: once_cell::sync::Lazy<EntryFunctionDecoderMa
             "account_rotate_authentication_key_with_rotation_capability".to_string(),
             Box::new(decoder::account_rotate_authentication_key_with_rotation_capability),
         );
+        map.insert(
+            "activity_maybe_fix_malformed".to_string(),
+            Box::new(decoder::activity_maybe_fix_malformed),
+        );
         map.insert(
             "burn_set_send_community".to_string(),
             Box::new(decoder::burn_set_send_community),

framework/libra-framework/sources/ol_sources/tests/page_rank.test.move

@@ -510,4 +510,61 @@ module ol_framework::test_page_rank {
 
   }
 
+
+  #[test(framework = @ol_framework)]
+  /// a root of trust user may have their score
+  /// reduced from the initial voting power
+  /// scenario: two root of trust users are created
+  /// one of them vouches for alice, who then vouches for bob
+  /// who subsequently vouches for a root of trust user root1
+  /// root0 -> alice -> bob -> root1
+  fun root_score_reduction(framework: &signer) {
+    // Set up the test base
+    let roots_sig = test_base(framework);
+
+    let root0 = vector::borrow(&roots_sig, 0);
+    vouch::init(root0);
+    let root0_addr = signer::address_of(root0);
+
+    let root1 = vector::borrow(&roots_sig, 1);
+    vouch::init(root1);
+    let root1_addr = signer::address_of(root1);
+
+
+    ///////// Root 0 score is initially 0 ////////
+    let root0_score_pre = page_rank_lazy::get_trust_score(root0_addr);
+    assert!(root0_score_pre == 0, 7357001);
+    let root1_score_pre = page_rank_lazy::get_trust_score(root1_addr);
+    assert!(root1_score_pre == 0, 7357002);
+    /////////
+
+    // Alice receives a vouch from root0
+    let alice_sig = mock::create_user_from_u64(framework, 11);
+    let alice_addr = signer::address_of(&alice_sig);
+    vouch::init(&alice_sig);
+    // Initialize page rank for the new user
+    page_rank_lazy::maybe_initialize_trust_record(&alice_sig);
+
+    // Alice vouches for bob
+    let bob_sig = mock::create_user_from_u64(framework, 12);
+    vouch::init(&bob_sig);
+    let bob_addr = signer::address_of(&bob_sig);
+    page_rank_lazy::maybe_initialize_trust_record(&bob_sig);
+
+    vouch_txs::vouch_for(root0, alice_addr);
+    vouch_txs::vouch_for(&alice_sig, bob_addr);
+
+    let bob_final_score = page_rank_lazy::get_trust_score(bob_addr);
+    assert!(bob_final_score == 50_000, 7357003);
+
+    vouch_txs::vouch_for(&bob_sig, root1_addr);
+
+    let root1_cached_score = page_rank_lazy::get_cached_score(root1_addr);
+    diem_std::debug::print(&root1_cached_score);
+
+    diem_std::debug::print(&7777777777777777777);
+
+    page_rank_lazy::refresh_cache(root1_addr);
+    // diem_std::debug::print(&root1_score_post);
+  }
 }

framework/libra-framework/sources/ol_sources/vouch_lib/page_rank_lazy.move

@@ -56,7 +56,6 @@ module ol_framework::page_rank_lazy {
 
     // Calculate or retrieve cached trust score
     public(friend) fun get_trust_score(addr: address): u64 acquires UserTrustRecord {
-        let current_timestamp = timestamp::now_seconds();
 
         // If user has no trust record, they have no score
         assert!(exists<UserTrustRecord>(addr), error::invalid_state(ENOT_INITIALIZED));
@@ -67,18 +66,26 @@ module ol_framework::page_rank_lazy {
         if (!user_record.is_stale) {
             return user_record.cached_score
         };
+        set_score(addr)
+    }
 
+    // always calculate the score
+    fun set_score(addr: address): u64 acquires UserTrustRecord {
+        // If user has no trust record, they have no score
+        assert!(exists<UserTrustRecord>(addr), error::invalid_state(ENOT_INITIALIZED));
         // Cache is stale or expired - compute fresh score
         // Default roots to system account if no registry
         let roots = root_of_trust::get_current_roots_at_registry(@diem_framework);
+        // diem_std::debug::print(&roots);
 
         // Compute score using selected algorithm
         let score = traverse_graph(&roots, addr);
+        diem_std::debug::print(&score);
 
         // Update the cache
         let user_record_mut = borrow_global_mut<UserTrustRecord>(addr);
         user_record_mut.cached_score = score;
-        user_record_mut.score_computed_at_timestamp = current_timestamp;
+        user_record_mut.score_computed_at_timestamp = timestamp::now_seconds();
         user_record_mut.is_stale = false;
 
         score
@@ -109,6 +116,7 @@ module ol_framework::page_rank_lazy {
                 );
             };
 
+
             root_idx = root_idx + 1;
         };
 
@@ -141,6 +149,8 @@ module ol_framework::page_rank_lazy {
 
         let (neighbors, _) = vouch::get_given_vouches(current);
         let neighbor_count = vector::length(&neighbors);
+        diem_std::debug::print(&current);
+        diem_std::debug::print(&neighbor_count);
 
         // No neighbors means no path
         if (neighbor_count == 0) {
@@ -150,45 +160,51 @@ module ol_framework::page_rank_lazy {
         // Track total score from all paths
         let total_score = 0;
 
+
         // Calculate power passed to neighbors (50% decay)
         let next_power = current_power / 2;
 
         // if the both current and target are a root of trust
-        // catch the case
+        // catch the case of a root of trust vouching for another root of trust
         // and exit early
-        if(
+        if (
           root_of_trust::is_root_at_registry(@diem_framework, current) &&
-          root_of_trust::is_root_at_registry(@diem_framework, target)
-          ) {
+          root_of_trust::is_root_at_registry(@diem_framework, target) &&
+          current != target &&
+          vector::contains(&neighbors, &target) // Check if current directly vouches for target
+        ) {
+            vector::push_back(visited, current);
             return next_power
         };
 
         // Check ALL neighbors for paths to target
         let i = 0;
         while (i < neighbor_count) {
+
             let neighbor = *vector::borrow(&neighbors, i);
+            diem_std::debug::print(&neighbor);
 
 
             // Only visit if not already in path (avoid cycles)
             if (!vector::contains(visited, &neighbor)) {
-                // Mark as visited
-                if (neighbor != target) {
-                    // Don't mark the target as visited
+                    if (neighbor != target) {
+                    // Mark neighbor as visited
+                    // (Don't mark the target as visited
                     // because we want to be able to
-                    // find it again
-                    // NOTE: fixes diamond pattern not accumulating
+                    // find it again)
 
                     vector::push_back(visited, neighbor);
+                    // we don't re-enter the root of
+                    // trust list, because we don't
+                    // want to accumulate points from
+                    // roots vouching for each other.
+                    if(
+                      root_of_trust::is_root_at_registry(@diem_framework, neighbor)
+                      ) {
+                        continue
+                    };
                 };
-                // we don't re-enter the root of
-                // trust list, because we don't
-                // want to accumulate points from
-                // roots vouching for each other.
-                if(
-                  root_of_trust::is_root_at_registry(@diem_framework, neighbor)
-                  ) {
-                    continue
-                };
+
 
                 // Continue search from this neighbor with reduced power
                 let path_score = walk_from_node(
@@ -281,7 +297,7 @@ module ol_framework::page_rank_lazy {
       // assert initialized
       assert!(exists<UserTrustRecord>(user), error::invalid_state(ENOT_INITIALIZED));
       // get_score
-      let _score = get_trust_score(user);
+      let _score = set_score(user);
     }
 
     //////// GETTERS ////////

types/src/core_types/network_playlist.rs

@@ -21,7 +21,7 @@ pub struct HostProfile {
 /// First does a light port check on all peers, and eliminated unresponsive
 /// Then from a random list fetches the first 3 nodes to respond with a waypoint.
 /// picks the node with the highest waypoint.
-/// moves that node othe top of the seed peers vector.
+/// moves that node to the top of the seed peers vector.
 /// sets it in preferences as the default peer.
 impl Default for HostProfile {
     fn default() -> Self {

types/src/lib.rs

@@ -18,5 +18,5 @@ pub fn global_config_dir() -> PathBuf {
         .join(GLOBAL_CONFIG_DIRECTORY_0L)
 }
 
-/// The coin scaling or decimal represenation of 1 coin in the VM. 1 coin is divisible by 1,000,000, or 6 decimals precision.
+/// The coin scaling or decimal representation of 1 coin in the VM. 1 coin is divisible by 1,000,000, or 6 decimals precision.
 pub const ONCHAIN_DECIMAL_PRECISION: u8 = 6;