feat: port v7 from release (#6884)

# Description of change

Ported the built `v7` binaries and the necessary code changes from
`v1.1.0`.
Moved all previous `v7` changes to `v8` and updated the version to
`v1.2.0-alpha`.

Author: alexsporn

Cargo.lock

@@ -170,7 +170,7 @@ members = [
 
 [workspace.package]
 # This version string will be inherited by iota-core, iota-faucet, iota-node, iota-tools, iota-sdk, iota-move-build, and iota crates.
-version = "1.1.0-alpha"
+version = "1.2.0-alpha"
 
 [profile.release]
 # debug = 1 means line charts only, which is minimum needed for good stack traces

Cargo.toml

@@ -180,7 +180,37 @@
     ]
   },
   "7": {
-    "git_revision": "a9d93ac5f371",
+    "git_revision": "58b8c8221b60",
+    "packages": [
+      {
+        "name": "MoveStdlib",
+        "path": "crates/iota-framework/packages/move-stdlib",
+        "id": "0x0000000000000000000000000000000000000000000000000000000000000001"
+      },
+      {
+        "name": "Iota",
+        "path": "crates/iota-framework/packages/iota-framework",
+        "id": "0x0000000000000000000000000000000000000000000000000000000000000002"
+      },
+      {
+        "name": "IotaSystem",
+        "path": "crates/iota-framework/packages/iota-system",
+        "id": "0x0000000000000000000000000000000000000000000000000000000000000003"
+      },
+      {
+        "name": "Bridge",
+        "path": "crates/iota-framework/packages/bridge",
+        "id": "0x000000000000000000000000000000000000000000000000000000000000000b"
+      },
+      {
+        "name": "Stardust",
+        "path": "crates/iota-framework/packages/stardust",
+        "id": "0x000000000000000000000000000000000000000000000000000000000000107a"
+      }
+    ]
+  },
+  "8": {
+    "git_revision": "32aced12b2d6",
     "packages": [
       {
         "name": "MoveStdlib",

crates/iota-framework-snapshot/bytecode_snapshot/7/0x0000000000000000000000000000000000000000000000000000000000000001

@@ -134,10 +134,19 @@ public(package) fun request_withdraw_stake(
     // stake is inactive
     if (staked_iota.stake_activation_epoch > ctx.epoch()) {
         let principal = unwrap_staked_iota(staked_iota);
-
-        // Stake for preactive validators is always processed immediately and not added to the pending stake.
-        if (!pool.is_preactive()) {
-            pool.pending_stake = pool.pending_stake - principal.value();
+        let withdraw_amount = principal.value();
+
+        if (pool.is_preactive()) {
+            // Stake for preactive validators is always processed immediately and not added to the pending stake.
+            // The exchange rate of a preactive pool is always 1:1, so we can subtract the withdraw_amount
+            // from both iota_balance and pool_token_balance.
+            pool.iota_balance = pool.iota_balance - withdraw_amount;
+            pool.pool_token_balance = pool.pool_token_balance - withdraw_amount;
+            check_balance_invariants(pool, ctx.epoch());
+        } else {
+            // The stake for active validators is only updated at epoch boundaries,
+            // so we can remove it from the pending_stake here.
+            pool.pending_stake = pool.pending_stake - withdraw_amount;
         };
 
         return principal
@@ -162,9 +171,6 @@ public(package) fun request_withdraw_stake(
     pool.pending_pool_token_withdraw =
         pool.pending_pool_token_withdraw + pool_token_withdraw_amount;
 
-    // If the pool is inactive, we immediately process the withdrawal.
-    if (is_inactive(pool)) process_pending_stake_withdraw(pool);
-
     // TODO: implement withdraw bonding period here.
     principal_withdraw.join(rewards_withdraw);
     principal_withdraw
@@ -235,8 +241,8 @@ public(package) fun process_pending_stakes_and_withdraws(
 }
 
 /// Called at epoch boundaries to process pending stake withdraws requested during the epoch.
-/// Also called immediately upon withdrawal if the pool is inactive.
-fun process_pending_stake_withdraw(pool: &mut StakingPoolV1) {
+/// Also called immediately upon withdrawal if the pool is inactive or if the pool is preactive.
+public(package) fun process_pending_stake_withdraw(pool: &mut StakingPoolV1) {
     pool.iota_balance = pool.iota_balance - pool.pending_total_iota_withdraw;
     pool.pool_token_balance = pool.pool_token_balance - pool.pending_pool_token_withdraw;
     pool.pending_total_iota_withdraw = 0;

crates/iota-framework-snapshot/bytecode_snapshot/7/0x0000000000000000000000000000000000000000000000000000000000000002

@@ -342,6 +342,10 @@ public(package) fun request_withdraw_stake(
     let principal_amount = staked_iota.staked_iota_amount();
     let stake_activation_epoch = staked_iota.stake_activation_epoch();
     let withdrawn_stake = self.staking_pool.request_withdraw_stake(staked_iota, ctx);
+    // Process withdraw right away if staking pool is preactive or inactive
+    if (self.staking_pool.is_preactive() || self.staking_pool.is_inactive()) {
+        self.staking_pool.process_pending_stake_withdraw();
+    };
     let withdraw_amount = withdrawn_stake.value();
     let reward_amount = withdraw_amount - principal_amount;
     self.next_epoch_stake = self.next_epoch_stake - withdraw_amount;
@@ -494,6 +498,10 @@ public fun total_stake(self: &ValidatorV1): u64 {
     stake_amount(self)
 }
 
+public(package) fun next_epoch_stake(self: &ValidatorV1): u64 {
+    self.next_epoch_stake
+}
+
 /// Return the voting power of this validator.
 public fun voting_power(self: &ValidatorV1): u64 {
     self.voting_power

crates/iota-framework-snapshot/bytecode_snapshot/7/0x0000000000000000000000000000000000000000000000000000000000000003

@@ -159,6 +159,7 @@ const EValidatorAlreadyRemoved: u64 = 11;
 const ENotAPendingValidator: u64 = 12;
 const EValidatorSetEmpty: u64 = 13;
 const ENotACommitteeValidator: u64 = 14;
+const EInvalidStakeAmount: u64 = 15;
 
 const EInvalidCap: u64 = 101;
 
@@ -342,6 +343,7 @@ public(package) fun request_add_validator(
         EDuplicateValidator,
     );
     assert!(validator.is_preactive(), EValidatorNotCandidate);
+    assert!(validator.total_stake_amount() == validator.next_epoch_stake(), EInvalidStakeAmount);
     assert!(validator.total_stake_amount() >= min_joining_stake_amount, EMinJoiningStakeNotReached);
 
     self.pending_active_validators.push_back(validator);

crates/iota-framework-snapshot/bytecode_snapshot/8/0x0000000000000000000000000000000000000000000000000000000000000001

@@ -16,6 +16,7 @@ use iota_system::governance_test_utils::{
     advance_epoch_with_max_committee_members_count,
     advance_epoch_with_balanced_reward_amounts,
     assert_validator_total_stake_amounts,
+    assert_validator_candidate_total_stake_amounts,
     create_validator_for_testing,
     create_iota_system_state_for_testing,
     stake_with,
@@ -563,6 +564,130 @@ fun test_add_preactive_remove_pending_failure() {
     scenario_val.end();
 }
 
+#[test]
+fun test_add_preactive_remove_preactive_check_total_stake_amount() {
+    set_up_iota_system_state();
+    let mut scenario_val = test_scenario::begin(VALIDATOR_ADDR_1);
+    let scenario = &mut scenario_val;
+
+    add_validator_candidate(
+        NEW_VALIDATOR_ADDR,
+        b"name5",
+        b"/ip4/127.0.0.1/udp/85",
+        NEW_VALIDATOR_PUBKEY,
+        NEW_VALIDATOR_POP,
+        scenario,
+    );
+
+    // Delegate 100 NANOS to the preactive validator
+    stake_with(STAKER_ADDR_1, NEW_VALIDATOR_ADDR, 100, scenario);
+
+    // Advance epoch with some rewards
+    advance_epoch_with_balanced_reward_amounts(0, 400, scenario);
+
+    // The preactive validator should have 100 NANOS total stake
+    assert_validator_candidate_total_stake_amounts(
+        vector[NEW_VALIDATOR_ADDR],
+        vector[100 * NANOS_PER_IOTA],
+        scenario,
+    );
+
+    // Unstake from the preactive validator. There should be no rewards earned.
+    unstake(STAKER_ADDR_1, 0, scenario);
+    assert_eq(total_iota_balance(STAKER_ADDR_1, scenario), 100 * NANOS_PER_IOTA);
+
+    // The preactive validator should have no stake since it got unstaked
+    assert_validator_candidate_total_stake_amounts(
+        vector[NEW_VALIDATOR_ADDR],
+        vector[0 * NANOS_PER_IOTA],
+        scenario,
+    );
+
+    // Advance epoch
+    advance_epoch_with_balanced_reward_amounts(0, 0, scenario);
+
+    // The preactive validator should still have no stake
+    assert_validator_candidate_total_stake_amounts(
+        vector[NEW_VALIDATOR_ADDR],
+        vector[0 * NANOS_PER_IOTA],
+        scenario,
+    );
+
+    // Join validators -> Pending
+    add_validator(NEW_VALIDATOR_ADDR, scenario);
+
+    // Transition validator from Pending -> Active
+    advance_epoch(scenario);
+
+    // Transition validator from Active -> Active
+    advance_epoch(scenario);
+
+    assert_validator_total_stake_amounts(
+        vector[NEW_VALIDATOR_ADDR],
+        vector[0 * NANOS_PER_IOTA],
+        scenario,
+    );
+
+    scenario_val.end();
+}
+
+#[test]
+fun test_add_preactive_remove_preactive_check_total_stake_amount_same_epoch() {
+    set_up_iota_system_state();
+    let mut scenario_val = test_scenario::begin(VALIDATOR_ADDR_1);
+    let scenario = &mut scenario_val;
+
+    add_validator_candidate(
+        NEW_VALIDATOR_ADDR,
+        b"name5",
+        b"/ip4/127.0.0.1/udp/85",
+        NEW_VALIDATOR_PUBKEY,
+        NEW_VALIDATOR_POP,
+        scenario,
+    );
+
+    // Delegate 100 NANOS to the preactive validator
+    stake_with(STAKER_ADDR_1, NEW_VALIDATOR_ADDR, 100, scenario);
+
+    // The preactive validator should have 100 NANOS total stake
+    assert_validator_candidate_total_stake_amounts(
+        vector[NEW_VALIDATOR_ADDR],
+        vector[100 * NANOS_PER_IOTA],
+        scenario,
+    );
+
+    // Unstake from the preactive validator. There should be no rewards earned.
+    unstake(STAKER_ADDR_1, 0, scenario);
+    assert_eq(total_iota_balance(STAKER_ADDR_1, scenario), 100 * NANOS_PER_IOTA);
+
+    // Advance epoch
+    advance_epoch_with_balanced_reward_amounts(0, 0, scenario);
+
+    // The preactive validator should have no stake since it got unstaked
+    assert_validator_candidate_total_stake_amounts(
+        vector[NEW_VALIDATOR_ADDR],
+        vector[0 * NANOS_PER_IOTA],
+        scenario,
+    );
+
+    // Join validators -> Pending
+    add_validator(NEW_VALIDATOR_ADDR, scenario);
+
+    // Transition validator from Pending -> Active
+    advance_epoch(scenario);
+
+    // Transition validator from Active -> Active
+    advance_epoch(scenario);
+
+    assert_validator_total_stake_amounts(
+        vector[NEW_VALIDATOR_ADDR],
+        vector[0 * NANOS_PER_IOTA],
+        scenario,
+    );
+
+    scenario_val.end();
+}
+
 #[test]
 #[expected_failure(abort_code = validator_set::ENotAValidator)]
 fun test_add_pending_failure() {

crates/iota-framework-snapshot/bytecode_snapshot/8/0x0000000000000000000000000000000000000000000000000000000000000002

@@ -559,7 +559,6 @@ public fun assert_validator_self_stake_amounts(
     while (i < validator_addrs.length()) {
         let validator_addr = validator_addrs[i];
         let amount = stake_amounts[i];
-
         scenario.next_tx(validator_addr);
         let mut system_state = scenario.take_shared<IotaSystemState>();
         let stake_plus_rewards = stake_plus_current_rewards_for_validator(
@@ -582,11 +581,10 @@ public fun assert_validator_total_stake_amounts(
     while (i < validator_addrs.length()) {
         let validator_addr = validator_addrs[i];
         let amount = stake_amounts[i];
-
         scenario.next_tx(validator_addr);
         let mut system_state = scenario.take_shared<IotaSystemState>();
         let validator_amount = system_state.validator_stake_amount(validator_addr);
-        assert!(validator_amount == amount, validator_amount);
+        assert_eq(validator_amount, amount);
         test_scenario::return_shared(system_state);
         i = i + 1;
     };
@@ -611,6 +609,27 @@ public fun assert_validator_non_self_stake_amounts(
     };
 }
 
+public fun assert_validator_candidate_total_stake_amounts(
+    validator_addrs: vector<address>,
+    stake_amounts: vector<u64>,
+    scenario: &mut Scenario,
+) {
+    let mut i = 0;
+    while (i < validator_addrs.length()) {
+        let validator_addr = validator_addrs[i];
+        let amount = stake_amounts[i];
+        scenario.next_tx(validator_addr);
+        let mut system_state = scenario.take_shared<IotaSystemState>();
+        let validator_amount = system_state
+            .validators()
+            .get_candidate_validator_ref(validator_addr)
+            .total_stake_amount();
+        assert_eq(validator_amount, amount);
+        test_scenario::return_shared(system_state);
+        i = i + 1;
+    };
+}
+
 /// Return the rewards for the validator at `addr` in terms of IOTA.
 public fun stake_plus_current_rewards_for_validator(
     addr: address,

crates/iota-framework-snapshot/bytecode_snapshot/8/0x0000000000000000000000000000000000000000000000000000000000000003

@@ -47,7 +47,7 @@ process_pending_stakes_and_withdraws
 	public(package) fun
 	0x3::staking_pool
 process_pending_stake_withdraw
-	fun
+	public(package) fun
 	0x3::staking_pool
 process_pending_stake
 	public(package) fun
@@ -253,6 +253,9 @@ stake_amount
 total_stake
 	public fun
 	0x3::validator
+next_epoch_stake
+	public(package) fun
+	0x3::validator
 voting_power
 	public fun
 	0x3::validator

crates/iota-framework-snapshot/bytecode_snapshot/8/0x000000000000000000000000000000000000000000000000000000000000000b

@@ -117,11 +117,11 @@ task 15, lines 64-69:
 Headers: {
     "content-type": "application/json",
     "content-length": "157",
-    "x-iota-rpc-version": "1.1.0-testing-no-sha",
+    "x-iota-rpc-version": "1.2.0-testing-no-sha",
     "vary": "origin, access-control-request-method, access-control-request-headers",
     "access-control-allow-origin": "*",
 }
-Service version: 1.1.0-testing-no-sha
+Service version: 1.2.0-testing-no-sha
 Response: {
   "data": {
     "checkpoint": {
@@ -378,7 +378,7 @@ Response: {
   "data": {
     "serviceConfig": {
       "availableVersions": [
-        "1.1"
+        "1.2"
       ]
     }
   }

crates/iota-framework-snapshot/bytecode_snapshot/8/0x000000000000000000000000000000000000000000000000000000000000107a

@@ -12,7 +12,7 @@
       "name": "Apache-2.0",
       "url": "https://raw.githubusercontent.com/iotaledger/iota/main/LICENSE"
     },
-    "version": "1.1.0-alpha"
+    "version": "1.2.0-alpha"
   },
   "methods": [
     {
@@ -1301,7 +1301,7 @@
             "name": "Result",
             "value": {
               "minSupportedProtocolVersion": "1",
-              "maxSupportedProtocolVersion": "7",
+              "maxSupportedProtocolVersion": "8",
               "protocolVersion": "6",
               "featureFlags": {
                 "accept_zklogin_in_multisig": false,