[move] ancestry not implemented for account creation (#131)

Co-authored-by: 0o-de-lally <[email protected]>

Author: codilion

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

@@ -4,23 +4,24 @@ module ol_framework::ancestry {
     use std::vector;
     use std::error;
     use std::option::{Self, Option};
-    // use std::debug::print;
     use diem_framework::system_addresses;
 
     friend ol_framework::vouch;
+    friend ol_framework::ol_account;
 
     /// two accounts are related by ancestry and should not be.
     const EACCOUNTS_ARE_FAMILY: u64 = 1;
+    /// no ancestry tree state on chain, this is probably a migration bug.
+    const ENO_ANCESTRY_TREE: u64 = 2;
 
     struct Ancestry has key {
       // the full tree back to genesis set
       tree: vector<address>,
     }
 
-    // this is limited to onboarding.
-    // TODO: limit this with `friend` of DiemAccount module.
-    public fun init(new_account_sig: &signer, onboarder_sig: &signer ) acquires Ancestry{
-        let parent = signer::address_of(onboarder_sig);
+    // this is limited to onboarding of users
+    public(friend) fun adopt_this_child(parent_sig: &signer, new_account_sig: &signer) acquires Ancestry{
+        let parent = signer::address_of(parent_sig);
         set_tree(new_account_sig, parent);
     }
 
@@ -58,49 +59,60 @@ module ol_framework::ancestry {
 
     #[view]
     /// Getter for user's unfiltered tree
+    /// @return vector of addresses if there is an ancestry struct
+    // Commit NOTE: any transitive function that the VM calls needs to check
+    // this struct exists.
     public fun get_tree(addr: address): vector<address> acquires Ancestry {
-      if (exists<Ancestry>(addr)) {
-        *&borrow_global<Ancestry>(addr).tree
-      } else {
-        vector::empty()
-      }
+      assert!(exists<Ancestry>(addr), ENO_ANCESTRY_TREE);
 
+      *&borrow_global<Ancestry>(addr).tree
     }
+
     /// helper function to check on transactions (e.g. vouch) if accounts are related
-    public fun assert_unrelated(left: address, right: address) acquires Ancestry{
+    public fun assert_unrelated(left: address, right: address) acquires
+    Ancestry{
       let (is, _) = is_family(left, right);
       assert!(!is, error::invalid_state(EACCOUNTS_ARE_FAMILY));
     }
 
     // checks if two addresses have an intersecting permission tree
     // will return true, and the common ancestor at the intersection.
-    // TODO: test if tree is empty does it abort.
     public fun is_family(left: address, right: address): (bool, address) acquires Ancestry {
       let is_family = false;
       let common_ancestor = @0x0;
 
-        let left_tree = get_tree(left);
-        let right_tree = get_tree(right);
+      // if there is no ancestry info this is a bug, assume related
+      // NOTE: we don't want to error here, since the VM calls this
+      // on epoch boundary
+      if (!exists<Ancestry>(left)) return (true, @0x666);
+      if (!exists<Ancestry>(right)) return (true, @0x666);
 
-        // check for direct relationship.
-        if (vector::contains(&left_tree, &right)) return (true, right);
-        if (vector::contains(&right_tree, &left)) return (true, left);
+      let left_tree = get_tree(left);
+      let right_tree = get_tree(right);
 
+      // check for direct relationship.
+      if (vector::contains(&left_tree, &right)) return (true, right);
+      if (vector::contains(&right_tree, &left)) return (true, left);
 
-        let i = 0;
-        // check every address on the list if there are overlaps.
-        while (i < vector::length<address>(&left_tree)) {
+      let i = 0;
+      // check every address on the list if there are overlaps.
+      while (i < vector::length<address>(&left_tree)) {
 
-          let family_addr = vector::borrow(&left_tree, i);
-          if (vector::contains(&right_tree, family_addr)) {
-            is_family = true;
-            common_ancestor = *family_addr;
+        let family_addr = vector::borrow(&left_tree, i);
+        if (vector::contains(&right_tree, family_addr)) {
+          is_family = true;
+          common_ancestor = *family_addr;
 
-            break
-          };
-          i = i + 1;
+          break
         };
+        i = i + 1;
+      };
 
+      // for TEST compatibility, either no ancestor is found
+      // or the Vm or Framework created accounts at genesis
+      if (system_addresses::is_reserved_address(common_ancestor)) {
+        is_family = false;
+      };
       (is_family, common_ancestor)
     }
 
@@ -201,4 +213,4 @@ module ol_framework::ancestry {
         child_ancestry.tree = migrate_tree;
       };
     }
-}
+}

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

@@ -22,7 +22,6 @@
 /// 4. CommunityWallets have a high threshold for sybils: all multisig authorities must be unrelated in their permission trees, per ancestry.
 
 module ol_framework::community_wallet {
-
     use std::error;
     use std::vector;
     use std::signer;
@@ -34,6 +33,8 @@ module ol_framework::community_wallet {
     use ol_framework::match_index;
     use diem_framework::system_addresses;
 
+    // use diem_std::debug::print;
+
     /// not authorized to operate on this account
     const ENOT_AUTHORIZED: u64 = 1;
     /// does not meet criteria for community wallet
@@ -153,7 +154,6 @@ module ol_framework::community_wallet {
       let n = (3 * len) / 5;
 
       let (fam, _, _) = ancestry::any_family_in_list(*&init_signers);
-
       assert!(!fam, error::invalid_argument(ESIGNERS_SYBIL));
 
       // set as donor directed with any liquidation going to existing matching index
@@ -184,4 +184,4 @@ module ol_framework::community_wallet {
         option::some(vote_duration_epochs)
       );
     }
-}
+}

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

@@ -246,7 +246,6 @@ module ol_framework::mock {
       let musical_chairs_default_seats = 10;
       musical_chairs::initialize(root, musical_chairs_default_seats);
 
-
       let val_addr = personas();
       let i = 0;
       while (i < num) {
@@ -255,7 +254,8 @@ module ol_framework::mock {
 
         let (_sk, pk, pop) = stake::generate_identity();
         // stake::initialize_test_validator(&pk, &pop, &sig, 100, true, true);
-        validator_universe::test_register_validator(root, &pk, &pop, &sig, 100, true, true);
+        validator_universe::test_register_validator(root, &pk, &pop, &sig, 100,
+        true, true);
 
         vouch::init(&sig);
         vouch::test_set_buddies(*val, val_addr);

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

@@ -12,6 +12,7 @@ module ol_framework::ol_account {
     use diem_std::math64;
 
 
+    use ol_framework::ancestry;
     use ol_framework::libra_coin::{Self, LibraCoin};
     use ol_framework::slow_wallet;
     use ol_framework::receipts;
@@ -84,21 +85,23 @@ module ol_framework::ol_account {
       let (resource_account_sig, cap) = account::create_resource_account(user, seed);
       coin::register<LibraCoin>(&resource_account_sig);
       (resource_account_sig, cap)
+      // adopt_this_child(user, resource_account_sig);
     }
 
-    fun create_impl(auth_key: address) {
-        let new_signer = account::create_account(auth_key);
+    fun create_impl(sender: &signer, maybe_new_user: address) {
+        let new_signer = account::create_account(maybe_new_user);
         coin::register<LibraCoin>(&new_signer);
         receipts::user_init(&new_signer);
         init_burn_tracker(&new_signer);
+        ancestry::adopt_this_child(sender, &new_signer);
     }
 
     // #[test_only]
     /// Helper for tests to create acounts
     /// Belt and suspenders
     public entry fun create_account(root: &signer, auth_key: address) {
         system_addresses::assert_ol(root);
-        create_impl(auth_key);
+        create_impl(root, auth_key);
     }
 
     /// For migrating accounts from a legacy system
@@ -156,15 +159,20 @@ module ol_framework::ol_account {
     public entry fun transfer(sender: &signer, to: address, amount: u64)
     acquires BurnTracker {
       let payer = signer::address_of(sender);
+      maybe_sender_creates_account(sender, to);
       transfer_checks(payer, to, amount);
       // both update burn tracker
       let c = withdraw(sender, amount);
       deposit_coins(to, c);
     }
 
-    // transfer with capability, and do appropriate checks on both sides, and track the slow wallet
-    public fun transfer_with_capability(cap: &WithdrawCapability, recipient:
+    // transfer with capability, and do appropriate checks on both sides, and
+    // track the slow wallet
+    // NOTE: this requires that the account exists, since the SENDER signature is not used
+    fun transfer_with_capability(cap: &WithdrawCapability, recipient:
     address, amount: u64) acquires BurnTracker {
+      if(!account::exists_at(recipient)) return; // exit without abort,
+      // since this might be called by the 0x0 at an epoch boundary.
       let payer = account::get_withdraw_cap_address(cap);
       transfer_checks(payer, recipient, amount);
       // NOTE: these shoud update BurnTracker
@@ -210,17 +218,18 @@ module ol_framework::ol_account {
         coin
     }
 
+    fun maybe_sender_creates_account(sender: &signer, maybe_new_user: address) {
+      if (!account::exists_at(maybe_new_user)) {
+          // creates the account address (with the same bytes as the authentication key).
+          create_impl(sender, maybe_new_user);
+      };
+    }
+
     // actual implementation to allow for capability
     fun transfer_checks(payer: address, recipient: address, amount: u64) {
         let limit = slow_wallet::unlocked_amount(payer);
         assert!(amount < limit, error::invalid_state(EINSUFFICIENT_BALANCE));
 
-        if (!account::exists_at(recipient)) {
-            // creates the account address (with the same bytes as the authentication key).
-            create_impl(recipient);
-        };
-
-
         // TODO: Check if Resource Accounts can register here, since they
         // may be created without any coin registration.
         assert!(coin::is_account_registered<LibraCoin>(recipient), error::invalid_argument(EACCOUNT_NOT_REGISTERED_FOR_GAS));

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

@@ -0,0 +1,42 @@
+#[test_only]
+
+/// tests for external apis, and where a dependency cycle with genesis is created.
+module ol_framework::test_account {
+  use std::vector;
+  use ol_framework::libra_coin;
+  use ol_framework::mock;
+  use ol_framework::ol_account;
+  use ol_framework::ancestry;
+  use diem_framework::coin;
+  use diem_std::debug::print;
+  // scenario: testing trying send more funds than are unlocked
+  #[test(root = @ol_framework, alice_sig = @0x1000a)]
+  fun test_account_create(root: signer, alice_sig: signer) {
+    let alice_addr = @0x1000a;
+    let bob_addr = @0x1000b;
+
+    mock::ol_test_genesis(&root);
+
+    let mint_cap = libra_coin::extract_mint_cap(&root);
+    ol_account::create_account(&root, alice_addr);
+    ol_account::deposit_coins(alice_addr, coin::test_mint(100, &mint_cap));
+    coin::destroy_mint_cap(mint_cap);
+
+    let addr_tree = ancestry::get_tree(alice_addr);
+    assert!(vector::length(&addr_tree) > 0, 7357001);
+    print(&addr_tree);
+    assert!(vector::contains(&addr_tree, &@0x1), 7357002);
+
+
+    let (a_balance, _) = ol_account::balance(alice_addr);
+    assert!(a_balance == 100, 735703);
+
+    ol_account::transfer(&alice_sig, bob_addr, 20);
+    let addr_tree = ancestry::get_tree(bob_addr);
+    assert!(vector::length(&addr_tree) > 1, 7357004);
+    assert!(vector::contains(&addr_tree, &alice_addr), 7357005);
+
+    print(&addr_tree);
+
+  }
+}

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

@@ -282,7 +282,7 @@ module ol_framework::test_burn {
     //   assert!(TransactionFee::get_fees_collected()==1, 735703);
     // }
 
-     #[test(root=@ol_framework, alice=@0x1000a)]
+    #[test(root=@ol_framework, alice=@0x1000a)]
     fun track_fees(root: &signer, alice: address) {
       // use ol_framework::libra_coin;
       let _vals = mock::genesis_n_vals(root, 1); // need to include eve to init funds

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

@@ -2,28 +2,21 @@
 // 0L Module
 // ValidatorUniverse
 ///////////////////////////////////////////////////////////////////////////
-// Stores all the validators who submitted a vdf proof.
-// File Prefix for errors: 2201
-///////////////////////////////////////////////////////////////////////////
 
 module diem_framework::validator_universe {
   use std::signer;
   use std::vector;
   use diem_framework::system_addresses;
   use ol_framework::jail;
-  // use ol_framework::grade;
   use ol_framework::vouch;
   use diem_framework::stake;
 
-  // use diem_framework::coin::Coin;
-  // use ol_framework::libra_coin::LibraCoin;
-  // use ol_framework::rewards;
 
   #[test_only]
   use ol_framework::testnet;
   #[test_only]
   use diem_std::bls12381;
-  // use diem_framework::account;
+
   // use diem_std::debug::print;
 
   friend diem_framework::reconfiguration;
@@ -64,7 +57,6 @@ module diem_framework::validator_universe {
       jail::init(account);
   }
 
-
   /// This function is called to add validator to the validator universe.
   fun add(sender: &signer) acquires ValidatorUniverse {
     let addr = signer::address_of(sender);
@@ -77,36 +69,6 @@ module diem_framework::validator_universe {
     jail::init(sender);
   }
 
-  // /// Used at epoch boundaries to evaluate the performance of the validator.
-  // /// only root can call this, and only by friend modules (reconfiguration). Belt and suspenders.
-  // public(friend) fun maybe_jail(root: &signer, validator: address): bool {
-  //   system_addresses::assert_ol(root);
-  //   maybe_jail_impl(root, validator)
-  // }
-
-  // /// Common implementation for maybe_jail.
-  // fun maybe_jail_impl(root: &signer, validator: address): bool {
-  //   system_addresses::assert_ol(root);
-
-  //   let (compliant, _, _, _) = grade::get_validator_grade(validator);
-  //     // TODO check if there are issues with config. belt and suspenders
-
-  //   if (compliant) {
-  //     jail::jail(root, validator);
-  //     return true
-  //   };
-
-  //   false
-  // }
-
-
-  // /// performs the business logic for admitting new validators
-  // /// includes proof-of-fee auction and collecting payment
-  // /// includes drawing from infrastructure escrow into transaction fee account
-  // public(friend) fun end_epoch_process_incoming() {
-
-  // }
-
   //////// GENESIS ////////
   /// For 0L genesis, initialize and add the validators
   /// both root and validator need to sign. This is only possible at genesis.
@@ -152,12 +114,6 @@ module diem_framework::validator_universe {
     add(validator);
   }
 
-  // #[test_only]
-  // /// test helper for maybe_jail
-  // public fun test_maybe_jail(root: &signer, validator: address): bool {
-  //   maybe_jail_impl(root, validator)
-  // }
-
   #[test_only]
   public fun test_helper_add_self_onboard(vm: &signer, addr:address) acquires ValidatorUniverse {
     assert!(testnet::is_testnet(), 220101014014);
@@ -178,6 +134,4 @@ module diem_framework::validator_universe {
       vector::remove<address>(&mut state.validators, index);
     }
   }
-
-
 }