[vouch] permanent vouches for non-validators (#430)

Co-authored-by: Rosina Von Legato <[email protected]>
Co-authored-by: Franci Marten <[email protected]>
Co-authored-by: Nora Hind <[email protected]>
Co-authored-by: sasuke0787 <[email protected]>
Co-authored-by: Mariella Fitz Hind <[email protected]>

Author: 6 people

framework/libra-framework/sources/ol_sources/ancestry.move

@@ -221,6 +221,12 @@ module ol_framework::ancestry {
         // for each account in list, compare to the others.
         // if they are unrelated, add them to the list.
         let target_acc = vector::borrow<address>(&list, i);
+        // check if the target account is initialized with ancestry.
+        if (!exists<Ancestry>(*target_acc)) {
+          // if not, skip it.
+          i = i + 1;
+          continue
+        };
 
         // now loop through all the accounts again, and check if this target
         // account is related to anyone.
@@ -229,6 +235,13 @@ module ol_framework::ancestry {
           let comparison_acc = vector::borrow(&list, k);
           // skip if you're the same person
           if (comparison_acc != target_acc) {
+            // check that the comparison account is initialized
+            // with ancestry.
+            if (!exists<Ancestry>(*comparison_acc)) {
+              k = k + 1;
+              continue
+            };
+
             // check ancestry algo
             let (is_fam, _parent) = is_family(*comparison_acc, *target_acc);
             if (!is_fam) {

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

@@ -0,0 +1,153 @@
+#[test_only]
+module ol_framework::test_permanent_vouches {
+    use std::vector;
+    use ol_framework::vouch;
+    use ol_framework::mock;
+    use ol_framework::epoch_helper;
+
+    #[test(root = @ol_framework, alice = @0x1000a, _bob = @0x1000b)]
+    fun vouch_persists_across_epochs(root: &signer, alice: &signer, _bob: &signer) {
+        // Initialize genesis and validators
+        mock::ol_test_genesis(root);
+        mock::create_validator_accounts(root, 2, false);
+        vouch::set_vouch_price(root, 0);
+        
+        // Alice vouches for Bob
+        vouch::vouch_for(alice, @0x1000b);
+        
+        // Verify vouch exists
+        let received_vouches = vouch::get_received_vouches_not_expired(@0x1000b);
+        assert!(vector::contains(&received_vouches, &@0x1000a), 1);
+        
+        // Simulate multiple epochs passing (more than old expiration limit)
+        let i = 0;
+        while (i < 50) {  // Beyond old EXPIRATION_ELAPSED_EPOCHS
+            mock::trigger_epoch(root);
+            i = i + 1;
+        };
+        
+        // Verify vouch still exists (permanent vouches)
+        let received_vouches_after = vouch::get_received_vouches_not_expired(@0x1000b);
+        assert!(vector::contains(&received_vouches_after, &@0x1000a), 2);
+    }
+
+    #[test(root = @ol_framework, alice = @0x1000a, _bob = @0x1000b)]
+    fun vouch_revocation_still_works(root: &signer, alice: &signer, _bob: &signer) {
+        // Initialize genesis and validators
+        mock::ol_test_genesis(root);
+        mock::create_validator_accounts(root, 2, false);
+        vouch::set_vouch_price(root, 0);
+        
+        // Alice vouches for Bob
+        vouch::vouch_for(alice, @0x1000b);
+        
+        // Verify vouch exists
+        let received_vouches = vouch::get_received_vouches_not_expired(@0x1000b);
+        assert!(vector::contains(&received_vouches, &@0x1000a), 1);
+        
+        // Alice revokes vouch for Bob
+        vouch::revoke(alice, @0x1000b);
+        
+        // Verify vouch is removed
+        let received_vouches_after = vouch::get_received_vouches_not_expired(@0x1000b);
+        assert!(!vector::contains(&received_vouches_after, &@0x1000a), 2);
+        
+        // Verify given vouches are also updated
+        let given_vouches = vouch::get_given_vouches_not_expired(@0x1000a);
+        assert!(!vector::contains(&given_vouches, &@0x1000b), 3);
+    }
+
+    #[test(root = @ol_framework, alice = @0x1000a, _bob = @0x1000b)]
+    fun vouch_update_extends_permanently(root: &signer, alice: &signer, _bob: &signer) {
+        // Initialize genesis and validators
+        mock::ol_test_genesis(root);
+        mock::create_validator_accounts(root, 2, false);
+        vouch::set_vouch_price(root, 0);
+        
+        // Alice vouches for Bob initially
+        vouch::vouch_for(alice, @0x1000b);
+        
+        let (_received_vouches, epochs) = vouch::get_received_vouches(@0x1000b);
+        let initial_epoch = *vector::borrow(&epochs, 0);
+        
+        // Advance one epoch to ensure difference
+        mock::trigger_epoch(root);
+        
+        // Alice vouches for Bob again (should update epoch)
+        vouch::vouch_for(alice, @0x1000b);
+        
+        let (received_vouches_after, epochs_after) = vouch::get_received_vouches(@0x1000b);
+        let updated_epoch = *vector::borrow(&epochs_after, 0);
+        
+        // Should still have exactly one vouch from Alice
+        assert!(vector::length(&received_vouches_after) == 1, 1);
+        assert!(vector::contains(&received_vouches_after, &@0x1000a), 2);
+        
+        // Epoch should be updated to current
+        let current_epoch = epoch_helper::get_current_epoch();
+        assert!(updated_epoch == current_epoch, 3);
+        assert!(updated_epoch >= initial_epoch, 4);
+    }
+
+    #[test(root = @ol_framework, alice = @0x1000a, _bob = @0x1000b, _charlie = @0x1000c)]
+    fun lifetime_tracking_with_permanent_vouches(root: &signer, alice: &signer, _bob: &signer, _charlie: &signer) {
+        // Initialize genesis and validators
+        mock::ol_test_genesis(root);
+        mock::create_validator_accounts(root, 3, false);
+        vouch::set_vouch_price(root, 0);
+        
+        // Alice vouches for both Bob and Charlie
+        vouch::vouch_for(alice, @0x1000b);
+        vouch::vouch_for(alice, @0x1000c);
+        
+        // Check that Alice's given count is 2
+        let given_vouches = vouch::get_given_vouches_not_expired(@0x1000a);
+        assert!(vector::length(&given_vouches) == 2, 1);
+        
+        // Alice revokes vouch for Bob
+        vouch::revoke(alice, @0x1000b);
+        
+        // Check that Alice's given count is now 1
+        let given_vouches_after = vouch::get_given_vouches_not_expired(@0x1000a);
+        assert!(vector::length(&given_vouches_after) == 1, 2);
+        assert!(vector::contains(&given_vouches_after, &@0x1000c), 3);
+        assert!(!vector::contains(&given_vouches_after, &@0x1000b), 4);
+    }
+
+    #[test(root = @ol_framework, alice = @0x1000a, _bob = @0x1000b)]
+    fun true_friends_with_permanent_vouches(root: &signer, alice: &signer, _bob: &signer) {
+        // Initialize genesis and validators
+        mock::ol_test_genesis(root);
+        mock::create_validator_accounts(root, 2, false);
+        vouch::set_vouch_price(root, 0);
+        
+        // Alice vouches for Bob
+        vouch::vouch_for(alice, @0x1000b);
+        
+        // Test the core permanent vouch functionality
+        // 1. Check that the raw vouch exists
+        let received_vouches = vouch::get_received_vouches_not_expired(@0x1000b);
+        assert!(vector::contains(&received_vouches, &@0x1000a), 1);
+        
+        // 2. Check that the given vouch exists
+        let given_vouches = vouch::get_given_vouches_not_expired(@0x1000a);
+        assert!(vector::contains(&given_vouches, &@0x1000b), 2);
+        
+        // 3. Verify that vouches persist after many epochs (permanent aspect)
+        let i = 0;
+        while (i < 10) {  // Multiple epochs to test persistence
+            mock::trigger_epoch(root);
+            i = i + 1;
+        };
+        
+        // Vouches should still exist after many epochs
+        let received_vouches_after = vouch::get_received_vouches_not_expired(@0x1000b);
+        assert!(vector::contains(&received_vouches_after, &@0x1000a), 3);
+        
+        let given_vouches_after = vouch::get_given_vouches_not_expired(@0x1000a);
+        assert!(vector::contains(&given_vouches_after, &@0x1000b), 4);
+        
+        // Note: We avoid testing true_friends and is_valid_voucher_for here because
+        // they apply ancestry filtering which may filter out vouches between test addresses
+    }
+}

framework/libra-framework/sources/ol_sources/validator_vouch.move

@@ -0,0 +1,91 @@
+
+module ol_framework::validator_vouch {
+    use std::signer;
+    use std::vector;
+    use ol_framework::epoch_helper;
+    use ol_framework::vouch;
+    use diem_framework::stake;
+
+    friend ol_framework::vouch_txs;
+
+    /// How many epochs must pass before the voucher expires.
+    const EXPIRATION_ELAPSED_EPOCHS: u64 = 45;
+
+    /// Returns true if both addresses are validators
+    fun both_are_validators(addr1: address, addr2: address): bool {
+        stake::is_valid(addr1) && stake::is_valid(addr2)
+    }
+
+    /// Filter expired vouches for validator accounts only
+    public fun filter_expired(account: address, list_addr: vector<address>, epoch_vouched: vector<u64>): vector<address> {
+        let valid_vouches = vector::empty<address>();
+        let current_epoch = epoch_helper::get_current_epoch();
+        let i = 0;
+        while (i < vector::length(&list_addr)) {
+            let vouch_received = vector::borrow(&list_addr, i);
+            let when_vouched = *vector::borrow(&epoch_vouched, i);
+            if (both_are_validators(account, *vouch_received)) {
+                // Only expire if both voucher and vouchee are validators
+                if ((when_vouched + EXPIRATION_ELAPSED_EPOCHS) > current_epoch) {
+                    vector::push_back(&mut valid_vouches, *vouch_received);
+                }
+            } else {
+                // Otherwise, never expire vouches
+                vector::push_back(&mut valid_vouches, *vouch_received);
+            };
+            i = i + 1;
+        };
+        valid_vouches
+    }
+
+
+    /// Garbage collect expired vouches for validator accounts using signer
+    public(friend) fun garbage_collect_expired_for_signer(user_sig: &signer)  {
+        let user = signer::address_of(user_sig);
+        let (outgoing_vouches, outgoing_epochs) = vouch::get_given_vouches(user);
+        let (incoming_vouches, incoming_epochs) = vouch::get_received_vouches(user);
+        garbage_collect_expired(user, outgoing_vouches, outgoing_epochs, incoming_vouches, incoming_epochs);
+    }
+
+    /// Garbage collect expired vouches for validator accounts only
+    fun garbage_collect_expired(user: address, outgoing_vouches: vector<address>, outgoing_epochs: vector<u64>, incoming_vouches: vector<address>, incoming_epochs: vector<u64>): (vector<address>, vector<u64>, vector<address>, vector<u64>) {
+        let current_epoch = epoch_helper::get_current_epoch();
+        let i = 0;
+        while (i < vector::length(&outgoing_vouches)) {
+            let vouch_received = vector::borrow(&outgoing_vouches, i);
+            let when_vouched = *vector::borrow(&outgoing_epochs, i);
+            if (both_are_validators(user, *vouch_received)) {
+                if ((when_vouched + EXPIRATION_ELAPSED_EPOCHS) <= current_epoch) {
+                    // Expired: remove vouch
+                    vouch::remove_vouch(user, *vouch_received);
+                }
+            };
+            // else: do nothing, non-validator vouches never expire
+            i = i + 1;
+        };
+
+        let i = 0;
+        while (i < vector::length(&incoming_vouches)) {
+            let vouch_received = vector::borrow(&incoming_vouches, i);
+            let when_vouched = *vector::borrow(&incoming_epochs, i);
+            if (both_are_validators(user, *vouch_received)) {
+                if ((when_vouched + EXPIRATION_ELAPSED_EPOCHS) <= current_epoch) {
+                    // Expired: remove vouch
+                    vouch::remove_vouch(*vouch_received, user);
+                }
+            };
+            // else: do nothing, non-validator vouches never expire
+            i = i + 1;
+        };
+        // No need to return filtered lists, as state is mutated directly
+        (vector::empty<address>(), vector::empty<u64>(), vector::empty<address>(), vector::empty<u64>())
+    }
+
+    #[view]
+    /// gets the received vouches not expired
+    // TODO: duplicated with true_friends
+    public fun get_received_vouches_not_expired(addr: address): vector<address> {
+      let (all_received, epoch_vouched) = vouch::get_received_vouches(addr);
+      filter_expired(addr, all_received, epoch_vouched)
+    }
+}