Deleted ManageNeuronResponse from governance.proto.

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

@@ -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: {}