refactor(nns): Delete ManageNeuronResponse from governance.proto. (dfinity#3573)

The idea here is very much the same as the [previous PR] in this
thread/series. Therefore, please see the description of the
aforementioned PR for an overview, and details.

[previous PR]:dfinity#3546

One difference here is that we only deleted the response type, not the
request type. In this case, deleting the request type is not possible,
because it is used (indirectly) by `Governance` (via `Proposal`). This
is an unusual situation; most request types do not have this property.

Author: daniel-wong-dfinity-org

rs/nns/governance/api/src/ic_nns_governance.pb.v1.rs

@@ -1,5 +1,5 @@
 use ic_base_types::PrincipalId;
-use ic_nns_common::pb::v1::NeuronId;
+use ic_nns_common::pb::v1::{NeuronId, ProposalId};
 use icp_ledger::protobuf::AccountIdentifier;
 
 /// The entity that owns the nodes that run the network.
@@ -1276,6 +1276,166 @@ pub mod manage_neuron_response {
         #[prost(message, tag = "14")]
         RefreshVotingPower(RefreshVotingPowerResponse),
     }
+
+    // Below, we should remove `manage_neuron_response::`, but that should be
+    // done later, so that the original PR that transplanted this code does not
+    // have "extra" refactoring in it.
+    impl ManageNeuronResponse {
+        pub fn is_err(&self) -> bool {
+            matches!(
+                &self.command,
+                Some(manage_neuron_response::Command::Error(_))
+            )
+        }
+
+        pub fn err_ref(&self) -> Option<&GovernanceError> {
+            match &self.command {
+                Some(manage_neuron_response::Command::Error(err)) => Some(err),
+                _ => None,
+            }
+        }
+
+        pub fn err(self) -> Option<GovernanceError> {
+            match self.command {
+                Some(manage_neuron_response::Command::Error(err)) => Some(err),
+                _ => None,
+            }
+        }
+
+        pub fn is_ok(&self) -> bool {
+            !self.is_err()
+        }
+
+        pub fn panic_if_error(self, msg: &str) -> Self {
+            if let Some(manage_neuron_response::Command::Error(err)) = &self.command {
+                panic!("{}: {:?}", msg, err);
+            }
+            self
+        }
+
+        // This is generic so that callers can pass either GovernanceError from
+        // the ic_nns_governance crate (notice the lack of "_api" at the end of
+        // the name!), in addition to GovernanceError from this crate.
+        pub fn error<E>(err: E) -> Self
+        where
+            GovernanceError: From<E>,
+        {
+            ManageNeuronResponse {
+                command: Some(Command::Error(GovernanceError::from(err))),
+            }
+        }
+
+        pub fn configure_response() -> Self {
+            ManageNeuronResponse {
+                command: Some(manage_neuron_response::Command::Configure(
+                    manage_neuron_response::ConfigureResponse {},
+                )),
+            }
+        }
+
+        pub fn disburse_response(transfer_block_height: u64) -> Self {
+            ManageNeuronResponse {
+                command: Some(manage_neuron_response::Command::Disburse(
+                    manage_neuron_response::DisburseResponse {
+                        transfer_block_height,
+                    },
+                )),
+            }
+        }
+
+        pub fn spawn_response(created_neuron_id: NeuronId) -> Self {
+            let created_neuron_id = Some(created_neuron_id);
+            ManageNeuronResponse {
+                command: Some(manage_neuron_response::Command::Spawn(
+                    manage_neuron_response::SpawnResponse { created_neuron_id },
+                )),
+            }
+        }
+
+        pub fn merge_maturity_response(response: MergeMaturityResponse) -> Self {
+            ManageNeuronResponse {
+                command: Some(manage_neuron_response::Command::MergeMaturity(response)),
+            }
+        }
+
+        pub fn stake_maturity_response(response: StakeMaturityResponse) -> Self {
+            ManageNeuronResponse {
+                command: Some(manage_neuron_response::Command::StakeMaturity(response)),
+            }
+        }
+
+        pub fn follow_response() -> Self {
+            ManageNeuronResponse {
+                command: Some(manage_neuron_response::Command::Follow(
+                    manage_neuron_response::FollowResponse {},
+                )),
+            }
+        }
+
+        pub fn make_proposal_response(proposal_id: ProposalId, message: String) -> Self {
+            let proposal_id = Some(proposal_id);
+            let message = Some(message);
+            ManageNeuronResponse {
+                command: Some(manage_neuron_response::Command::MakeProposal(
+                    manage_neuron_response::MakeProposalResponse {
+                        proposal_id,
+                        message,
+                    },
+                )),
+            }
+        }
+
+        pub fn register_vote_response() -> Self {
+            ManageNeuronResponse {
+                command: Some(manage_neuron_response::Command::RegisterVote(
+                    manage_neuron_response::RegisterVoteResponse {},
+                )),
+            }
+        }
+
+        pub fn split_response(created_neuron_id: NeuronId) -> Self {
+            let created_neuron_id = Some(created_neuron_id);
+            ManageNeuronResponse {
+                command: Some(manage_neuron_response::Command::Split(
+                    manage_neuron_response::SplitResponse { created_neuron_id },
+                )),
+            }
+        }
+
+        pub fn merge_response(merge_response: manage_neuron_response::MergeResponse) -> Self {
+            ManageNeuronResponse {
+                command: Some(manage_neuron_response::Command::Merge(merge_response)),
+            }
+        }
+
+        pub fn disburse_to_neuron_response(created_neuron_id: NeuronId) -> Self {
+            let created_neuron_id = Some(created_neuron_id);
+            ManageNeuronResponse {
+                command: Some(manage_neuron_response::Command::DisburseToNeuron(
+                    manage_neuron_response::DisburseToNeuronResponse { created_neuron_id },
+                )),
+            }
+        }
+
+        pub fn claim_or_refresh_neuron_response(refreshed_neuron_id: NeuronId) -> Self {
+            let refreshed_neuron_id = Some(refreshed_neuron_id);
+            ManageNeuronResponse {
+                command: Some(manage_neuron_response::Command::ClaimOrRefresh(
+                    manage_neuron_response::ClaimOrRefreshResponse {
+                        refreshed_neuron_id,
+                    },
+                )),
+            }
+        }
+
+        pub fn refresh_voting_power_response(_: ()) -> Self {
+            ManageNeuronResponse {
+                command: Some(manage_neuron_response::Command::RefreshVotingPower(
+                    manage_neuron_response::RefreshVotingPowerResponse {},
+                )),
+            }
+        }
+    }
 }
 
 #[derive(candid::CandidType, candid::Deserialize, serde::Serialize, comparable::Comparable)]

rs/nns/governance/api/src/pb.rs

@@ -1,8 +1,8 @@
 use crate::pb::v1::{
-    governance::migration::MigrationStatus, governance_error::ErrorType, manage_neuron_response,
-    neuron::DissolveState, CreateServiceNervousSystem, GovernanceError, ManageNeuronResponse,
-    NetworkEconomics, Neuron, NeuronState, NeuronsFundEconomics,
-    NeuronsFundMatchedFundingCurveCoefficients, VotingPowerEconomics, XdrConversionRate,
+    governance::migration::MigrationStatus, governance_error::ErrorType, neuron::DissolveState,
+    CreateServiceNervousSystem, GovernanceError, NetworkEconomics, Neuron, NeuronState,
+    NeuronsFundEconomics, NeuronsFundMatchedFundingCurveCoefficients, VotingPowerEconomics,
+    XdrConversionRate,
 };
 use ic_nervous_system_common::{ONE_DAY_SECONDS, ONE_MONTH_SECONDS};
 use ic_nervous_system_proto::pb::v1::{Decimal, Duration, GlobalTimeOfDay, Percentage};
@@ -16,15 +16,6 @@ pub mod v1;
 /// The number of e8s per ICP;
 const E8S_PER_ICP: u64 = TOKEN_SUBDIVIDABLE_BY;
 
-impl ManageNeuronResponse {
-    pub fn panic_if_error(self, msg: &str) -> Self {
-        if let Some(manage_neuron_response::Command::Error(err)) = &self.command {
-            panic!("{}: {:?}", msg, err);
-        }
-        self
-    }
-}
-
 impl GovernanceError {
     pub fn new(error_type: ErrorType) -> Self {
         Self {

rs/nns/governance/canbench/canbench_results.yml

@@ -55,7 +55,7 @@ benches:
     scopes: {}
   compute_ballots_for_new_proposal_with_stable_neurons:
     total:
-      instructions: 2169168
+      instructions: 2220000
       heap_increase: 0
       stable_memory_increase: 0
     scopes: {}

rs/nns/governance/canister/canister.rs

@@ -703,11 +703,9 @@ async fn transfer_gtc_neuron(
 #[update]
 async fn manage_neuron(_manage_neuron: ManageNeuronRequest) -> ManageNeuronResponse {
     debug_log("manage_neuron");
-    ManageNeuronResponse::from(
-        governance_mut()
-            .manage_neuron(&caller(), &(gov_pb::ManageNeuron::from(_manage_neuron)))
-            .await,
-    )
+    governance_mut()
+        .manage_neuron(&caller(), &(gov_pb::ManageNeuron::from(_manage_neuron)))
+        .await
 }
 
 #[cfg(feature = "test")]
@@ -724,9 +722,7 @@ fn update_neuron(neuron: Neuron) -> Option<GovernanceError> {
 #[update]
 fn simulate_manage_neuron(manage_neuron: ManageNeuronRequest) -> ManageNeuronResponse {
     debug_log("simulate_manage_neuron");
-    let response =
-        governance().simulate_manage_neuron(&caller(), gov_pb::ManageNeuron::from(manage_neuron));
-    ManageNeuronResponse::from(response)
+    governance().simulate_manage_neuron(&caller(), gov_pb::ManageNeuron::from(manage_neuron))
 }
 
 #[query]

rs/nns/governance/proto/ic_nns_governance/pb/v1/governance.proto

@@ -1224,88 +1224,6 @@ message ManageNeuron {
   }
 }
 
-// The response of the ManageNeuron command
-//
-// There is a dedicated response type for each `ManageNeuron.command` field
-message ManageNeuronResponse {
-  message ConfigureResponse {}
-
-  message DisburseResponse {
-    // The block height at which the disburse transfer happened
-    uint64 transfer_block_height = 1;
-  }
-
-  message SpawnResponse {
-    // The ID of the Neuron created from spawning a Neuron
-    ic_nns_common.pb.v1.NeuronId created_neuron_id = 1;
-  }
-
-  message MergeMaturityResponse {
-    uint64 merged_maturity_e8s = 1;
-    uint64 new_stake_e8s = 2;
-  }
-
-  message StakeMaturityResponse {
-    uint64 maturity_e8s = 1;
-    uint64 staked_maturity_e8s = 2;
-  }
-
-  message FollowResponse {}
-
-  message MakeProposalResponse {
-    // The ID of the created proposal
-    ic_nns_common.pb.v1.ProposalId proposal_id = 1;
-    optional string message = 2;
-  }
-
-  message RegisterVoteResponse {}
-
-  message SplitResponse {
-    // The ID of the Neuron created from splitting another Neuron
-    ic_nns_common.pb.v1.NeuronId created_neuron_id = 1;
-  }
-
-  // A response for merging or simulating merge neurons
-  message MergeResponse {
-    // The resulting state of the source neuron
-    Neuron source_neuron = 1;
-    // The resulting state of the target neuron
-    Neuron target_neuron = 2;
-    // The NeuronInfo of the source neuron
-    NeuronInfo source_neuron_info = 3;
-    // The NeuronInfo of the target neuron
-    NeuronInfo target_neuron_info = 4;
-  }
-
-  message DisburseToNeuronResponse {
-    // The ID of the Neuron created from disbursing a Neuron
-    ic_nns_common.pb.v1.NeuronId created_neuron_id = 1;
-  }
-
-  message ClaimOrRefreshResponse {
-    ic_nns_common.pb.v1.NeuronId refreshed_neuron_id = 1;
-  }
-
-  message RefreshVotingPowerResponse {}
-
-  oneof command {
-    GovernanceError error = 1;
-    ConfigureResponse configure = 2;
-    DisburseResponse disburse = 3;
-    SpawnResponse spawn = 4;
-    FollowResponse follow = 5;
-    MakeProposalResponse make_proposal = 6;
-    RegisterVoteResponse register_vote = 7;
-    SplitResponse split = 8;
-    DisburseToNeuronResponse disburse_to_neuron = 9;
-    ClaimOrRefreshResponse claim_or_refresh = 10;
-    MergeMaturityResponse merge_maturity = 11;
-    MergeResponse merge = 12;
-    StakeMaturityResponse stake_maturity = 13;
-    RefreshVotingPowerResponse refresh_voting_power = 14;
-  }
-}
-
 message GovernanceError {
   enum ErrorType {
     ERROR_TYPE_UNSPECIFIED = 0;