Teams - Phase 1

json-rpc/src/data.rs

@@ -301,8 +301,6 @@ pub fn get_miner_state(
         Some(s) => TowerStateResourceView::try_from(s).map_err(Into::into),
         None => Err(JsonRpcError::internal_error("No account state found".to_owned())),
     }
-
-
 }
 
 /// Get miner state

json-rpc/types/src/views.rs

@@ -1493,7 +1493,6 @@ impl TryFrom<AccountState> for OracleUpgradeStateView {
         } else {
           Err(Error::msg("could not get upgrade oracle data"))
         }
-
     }
 }
 

language/diem-framework/modules/0L/Reconfigure.move → language/diem-framework/modules/0L/EpochBoundary.move

@@ -52,6 +52,9 @@ module EpochBoundary { // TODO: Rename to Boundary
             DiemAccount::slow_wallet_epoch_drip(vm, Globals::get_unlock());
             // update_validator_withdrawal_limit(vm);
         };
+
+        do_migrations(vm);
+
         reset_counters(vm, proposed_set, height_now)
     }
 
@@ -177,5 +180,12 @@ module EpochBoundary { // TODO: Rename to Boundary
         AutoPay::reconfig_reset_tick(vm);
         Epoch::reset_timer(vm, height_now);
     }
+
+    use 0x1::MigrateInitDelegation;
+    fun do_migrations(vm: &signer) {
+      // these need to run on an upgrade where a new data structure is introduced.
+      MigrateInitDelegation::do_it(vm);
+    }
+
 }
 }

language/diem-framework/modules/0L/Migrations.move

@@ -86,37 +86,4 @@ module Migrations {
     Option::none<Job>()
   }
 }
-
-/// # Summary 
-/// Module providing method to convert all wallets to "slow wallets" 
-/// migrations should have own module, since imports can cause dependency cycling.
-module MigrateWallets {
-  use 0x1::Vector;
-  use 0x1::Migrations;
-  use 0x1::DiemAccount;
-  use 0x1::ValidatorUniverse;
-  use 0x1::CoreAddresses;
-
-  const UID: u64 = 10;
-
-  // Migration to migrate all wallets to be slow wallets
-  public fun migrate_slow_wallets(vm: &signer) {
-    CoreAddresses::assert_diem_root(vm);
-    if (!Migrations::has_run(UID)) {
-      let vec_addr = ValidatorUniverse::get_eligible_validators(vm);
-      // TODO: how to get other accounts?
-
-      // tag all accounts as slow wallets
-      let len = Vector::length<address>(&vec_addr);
-      let i = 0;
-      while (i < len) {
-        let addr = *Vector::borrow<address>(&vec_addr, i);
-        DiemAccount::vm_migrate_slow_wallet(vm, addr);
-        i = i + 1;
-      };
-      Migrations::push(vm, UID, b"MigrateWallets");
-    };
-  }
-
-}
 }

language/diem-framework/modules/0L/Subsidy.move

@@ -24,6 +24,7 @@ address 0x1 {
     use 0x1::ValidatorConfig;
     use 0x1::TowerState;
     use 0x1::FixedPoint32;
+    use 0x1::Teams;
 
     // estimated gas unit cost for proof verification divided coin scaling factor
     // Cost for verification test/easy difficulty: 1173 / 1000000
@@ -52,22 +53,98 @@ address 0x1 {
 
       let i = 0;
       while (i < len) {
-        let node_address = *(Vector::borrow<address>(outgoing_set, i));
+        let node_address = Vector::borrow<address>(outgoing_set, i);
         // Transfer gas from vm address to validator
-        let minted_coins = Diem::mint<GAS>(vm, subsidy_granted);
-        DiemAccount::vm_deposit_with_metadata<GAS>(
-          vm,
-          node_address,
-          minted_coins,
-          b"validator subsidy",
-          b""
-        );
+        check_team_and_pay(vm, node_address, subsidy_granted);
 
         // refund operator tx fees for mining
-        refund_operator_tx_fees(vm, node_address);
+        refund_operator_tx_fees(vm, *node_address);
         i = i + 1;
       };
     }
+    use 0x1::Debug::print;
+
+    fun check_team_and_pay(vm: &signer, captain_address: &address, subsidy_granted: u64) {
+      // this is a solo validator. Exists during transition to delegation mode. This is a fallback condition to keep the node from halting
+      print(&100000);
+      let captain_value = subsidy_granted;
+      print(&subsidy_granted);
+      if (Teams::team_is_init(*captain_address)) {
+        print(&100100);
+        // split captain reward and send to captain.
+        let captain_pct = Teams::get_operator_reward(*captain_address);
+        print(&captain_pct);
+        // split off the captain value
+        captain_value = FixedPoint32::multiply_u64(
+          subsidy_granted,
+          FixedPoint32::create_from_rational(captain_pct, 100) 
+        );
+        print(&100200);
+        print(&captain_value);
+
+        let value_to_members = subsidy_granted - captain_value;
+        print(&value_to_members);
+
+        // get team members
+        let members = Teams::get_team_members(*captain_address);
+        // split the team subsidy
+        print(&100300);
+        split_subsidy_to_team(vm, &members, value_to_members);
+      };
+      print(&100400);
+      print(&captain_value);
+      let captain_coins = Diem::mint<GAS>(vm, captain_value);
+
+      let pre_balance = DiemAccount::balance<GAS>(*captain_address);
+      print(&pre_balance);
+
+      // payment to captain
+      DiemAccount::vm_deposit_with_metadata<GAS>(
+        vm,
+        *captain_address,
+        captain_coins,
+        b"validator subsidy",
+        b""
+      );
+    }
+
+    public fun split_subsidy_to_team(vm: &signer, members: &vector<address>, value_to_members: u64) {
+      let collective_height = TowerState::collective_tower_height(members);
+      print(&100310);
+      print(members);
+      print(&collective_height);
+      print(&value_to_members);
+      let i = 0;
+      while (i < Vector::length(members)) {
+        let addr = Vector::borrow(members, i);
+        let one_height = TowerState::tower_for_teams(*addr);
+        print(&100320);
+        print(&one_height);
+        if (one_height > 0) {
+          let payment_to_this_member = FixedPoint32::multiply_u64(
+            value_to_members,
+            FixedPoint32::create_from_rational(one_height, collective_height)
+          );
+          print(&100330);
+          print(&payment_to_this_member);
+
+          // let payment_to_this_member = value_to_members * pct;
+          // print(&payment_to_this_member);
+          let minted_coins = Diem::mint<GAS>(vm, payment_to_this_member);
+          let pre_balance = DiemAccount::balance<GAS>(*addr);
+          print(&pre_balance);
+          DiemAccount::vm_deposit_with_metadata<GAS>(
+              vm,
+              *addr,
+              minted_coins,
+              b"team consensus payment",
+              b""
+          );
+        };
+        i = i + 1;
+      }
+    }
+
 
     // Function code: 02 Prefix: 190102
     public fun calculate_subsidy(vm: &signer, network_density: u64): (u64, u64) {

language/diem-framework/modules/0L/Teams.move

@@ -0,0 +1,162 @@
+///////////////////////////////////////////////////////////////////////////
+// 0L Module
+// Teams 
+///////////////////////////////////////////////////////////////////////////
+// Used for coordinating "Teams", equivalent to delegation
+// Teams are groups which engage in work.
+// some of that work is automated such as validation.
+// A Team has a collective "consensus weight", which is used for voting in consensus
+// but also for stdlib upgrades.
+// Team members can share in a validator's rewards, but can also be used for coordinating
+// other activity, like projects and bounties.
+// File Prefix for errors: TBD
+///////////////////////////////////////////////////////////////////////////
+
+address 0x1 {
+module Teams {
+    use 0x1::CoreAddresses;
+    use 0x1::Vector;
+    use 0x1::Signer;
+    use 0x1::DiemAccount;
+    use 0x1::ValidatorUniverse;
+
+    const ENOT_SLOW_WALLET: u64 = 1010;
+
+    struct AllTeams has key, copy, drop, store {
+      teams_list: vector<address>, // the team is identified by its captain.
+
+    }
+
+    struct Team has key, copy, drop, store {
+      captain: address, // A validator account. TODO this is redundant, since it is stored in the validator account. But placed here for future-proofing.
+      team_name: vector<u8>, // A validator account.
+      members: vector<address>,
+      operator_pct_reward: u64, // the percentage of the rewards that the captain proposes to go to the validator operator.
+      collective_tower_height_this_epoch: u64,
+    }
+
+    // this struct is stored in the member's account
+    struct Member has key, copy, drop, store {
+      captain_address: address, // by address of captain
+      mining_above_threshold: bool, // if the mining the user has done is above the system threshold to count toward delegation.
+
+    }
+
+    public fun vm_init(sender: &signer) {
+      CoreAddresses::assert_vm(sender);
+      move_to<AllTeams>(
+        sender, 
+        AllTeams {
+          teams_list: Vector::empty()
+        }
+      );
+    }
+
+
+    public fun team_init(sender: &signer, team_name: vector<u8>, operator_pct_reward: u64) {
+
+      assert(ValidatorUniverse::is_in_universe(Signer::address_of(sender)), 201301001);
+      // An "captain", who is already a validator account, stores the Team struct on their account.
+      // the AllTeams struct is saved in the 0x0 account, and needs to be initialized before this is called.
+
+      // check vm has initialized the struct, otherwise exit early.
+      if (!exists<AllTeams>(CoreAddresses::VM_RESERVED_ADDRESS())) {
+        return
+    };
+
+    move_to<Team>(
+        sender, 
+        Team {
+          captain: Signer::address_of(sender), // A validator account.
+          team_name, // A validator account.
+          members: Vector::empty<address>(),
+          operator_pct_reward, // the percentage of the rewards that the captain proposes to go to the validator operator.
+          collective_tower_height_this_epoch: 0,
+        }
+      );
+    }
+
+    public fun join_team(sender: &signer, captain_address: address) acquires Member, Team {
+      let addr = Signer::address_of(sender);
+
+      // needs to check if this is a slow wallet.
+      // ask user to resubmit if not a slow wallet, so they are explicitly setting it, no surprises, no tears.
+
+     assert(DiemAccount::is_slow(addr), ENOT_SLOW_WALLET);
+
+
+      // bob wants to switch to a different Team.
+      if (exists<Member>(addr)) {
+        let member_state = borrow_global_mut<Member>(addr);
+        // update the membership list of the former captain
+        let former_captain_state = borrow_global_mut<Team>(member_state.captain_address);
+        let (is_found, idx) = Vector::index_of(&former_captain_state.members, &addr);
+        if (is_found) {
+          Vector::remove(&mut former_captain_state.members, idx);
+          member_state.captain_address = captain_address;
+        };        
+        // TODO: Do we need to reset mining_above_threshold if they are switching?
+      } else { // first time joining a Team.
+        move_to<Member>(sender, Member {
+          captain_address,
+          mining_above_threshold: false,
+        });
+      };
+      let captain_state = borrow_global_mut<Team>(captain_address);
+      Vector::push_back<address>(&mut captain_state.members, addr);
+    }
+
+
+    //////// GETTERS ////////
+
+    public fun get_all_teams(): vector<address> acquires AllTeams {
+      if (exists<AllTeams>(CoreAddresses::VM_RESERVED_ADDRESS())) {
+        let list = borrow_global<AllTeams>(CoreAddresses::VM_RESERVED_ADDRESS());
+        return *&list.teams_list
+      } else {
+        Vector::empty<address>()
+      }
+    }
+
+    public fun team_is_init(captain: address): bool {
+      exists<Team>(captain)
+    }
+
+    // NOTE: Important! The EpochBoundary will call this. This function cannot abort, must not halt consensus.
+    public fun get_operator_reward(captain: address):u64 acquires Team {
+      if (team_is_init(captain)) {
+        let s = borrow_global_mut<Team>(captain);
+        return *&s.operator_pct_reward
+      };
+      0
+    }
+    // find the team members
+    public fun get_team_members(captain: address):vector<address> acquires Team {
+      if (team_is_init(captain)) {
+        let s = borrow_global_mut<Team>(captain);
+        return *&s.members
+      };
+      Vector::empty<address>()
+    }
+
+    public fun vm_is_init(): bool {
+      exists<AllTeams>(CoreAddresses::VM_RESERVED_ADDRESS())
+    }
+}
+
+// Module for initializing Teams on a hot upgrade of stdlib.
+// since the system is likely operating and Teams are introduced as an upgrade, the structs need to be initalized.
+
+module MigrateInitDelegation {
+  use 0x1::Teams;
+  use 0x1::Migrations;
+  const UID: u64 = 101;
+  public fun do_it(vm: &signer) {
+    if (!Migrations::has_run(UID)) {
+      Teams::vm_init(vm);
+      Migrations::push(vm, UID, b"MigrateInitTeams");
+    }
+  }
+}
+}
+