chore(icp-rosetta): [FI-1563] Migrate Rosetta's voting tests (dfinity#2815)

This PR migrates ICP rosetta's voting functionality tests to pocket ic
based system tests

Author: Felipe Sodré

Cargo.lock

@@ -8,6 +8,7 @@ DEPENDENCIES = [
     "//rs/crypto/ed25519",
     "//rs/crypto/secp256k1",
     "//rs/ledger_suite/icp:icp_ledger",
+    "//rs/nns/governance/api",
     "//rs/rosetta-api/common/rosetta_core:rosetta-core",
     "//rs/rosetta-api/icp:ic-rosetta-api",
     "//rs/rosetta-api/icp:rosetta-api",

rs/rosetta-api/icp/client/BUILD.bazel

@@ -24,6 +24,7 @@ ic-crypto-ed25519 = { path = "../../../crypto/ed25519" }
 icp-ledger = { path = "../../../ledger_suite/icp" }
 icrc-ledger-types = { path = "../../../../packages/icrc-ledger-types" }
 ic-base-types = { path = "../../../types/base_types" }
+ic-nns-governance-api = { path = "../../../nns/governance/api" }
 
 [dev-dependencies]
 ic-icp-rosetta-runner = { path = "../runner" }

rs/rosetta-api/icp/client/Cargo.toml

@@ -3,6 +3,8 @@ use anyhow::Context;
 use candid::Nat;
 use candid::Principal;
 use ic_base_types::PrincipalId;
+use ic_nns_governance_api::pb::v1::Proposal;
+use ic_rosetta_api::ledger_client::pending_proposals_response::PendingProposalsResponse;
 use ic_rosetta_api::models::seconds::Seconds;
 use ic_rosetta_api::models::AccountType;
 use ic_rosetta_api::models::BlockIdentifier;
@@ -16,6 +18,7 @@ use ic_rosetta_api::request_types::KeyMetadata;
 use ic_rosetta_api::request_types::NeuronIdentifierMetadata;
 use ic_rosetta_api::request_types::NeuronInfoMetadata;
 use ic_rosetta_api::request_types::PublicKeyOrPrincipal;
+use ic_rosetta_api::request_types::RegisterVoteMetadata;
 use ic_rosetta_api::request_types::RequestType;
 use ic_rosetta_api::request_types::SetDissolveTimestampMetadata;
 use ic_rosetta_api::request_types::SpawnMetadata;
@@ -32,6 +35,7 @@ use rosetta_core::identifiers::TransactionIdentifier;
 use rosetta_core::models::CurveType;
 use rosetta_core::models::RosettaSupportedKeyPair;
 use rosetta_core::objects::Amount;
+use rosetta_core::objects::ObjectMap;
 use rosetta_core::objects::Operation;
 use rosetta_core::objects::PublicKey;
 use rosetta_core::objects::Signature;
@@ -40,7 +44,6 @@ use rosetta_core::response_types::*;
 use serde::{Deserialize, Serialize};
 use std::fmt::Debug;
 use url::ParseError;
-
 pub struct RosettaClient {
     pub url: Url,
     pub http_client: Client,
@@ -304,6 +307,37 @@ impl RosettaClient {
         }])
     }
 
+    pub async fn build_register_vote_operations(
+        signer_principal: Principal,
+        neuron_index: u64,
+        proposal: u64,
+        vote: i32,
+    ) -> anyhow::Result<Vec<Operation>> {
+        Ok(vec![Operation {
+            operation_identifier: OperationIdentifier {
+                index: 0,
+                network_index: None,
+            },
+            related_operations: None,
+            type_: "REGISTER_VOTE".to_string(),
+            status: None,
+            account: Some(rosetta_core::identifiers::AccountIdentifier::from(
+                AccountIdentifier::new(PrincipalId(signer_principal), None),
+            )),
+            amount: None,
+            coin_change: None,
+            metadata: Some(
+                RegisterVoteMetadata {
+                    neuron_index,
+                    vote,
+                    proposal: Some(proposal),
+                }
+                .try_into()
+                .map_err(|e| anyhow::anyhow!("Failed to convert metadata: {:?}", e))?,
+            ),
+        }])
+    }
+
     pub async fn build_change_auto_stake_maturity_operations(
         signer_principal: Principal,
         neuron_index: u64,
@@ -1129,6 +1163,59 @@ impl RosettaClient {
         .await
     }
 
+    // Register a vote on a proposal using a specific neuron.
+    pub async fn register_vote<T>(
+        &self,
+        network_identifier: NetworkIdentifier,
+        signer_keypair: &T,
+        register_vote_args: RosettaRegisterVoteArgs,
+    ) -> anyhow::Result<ConstructionSubmitResponse>
+    where
+        T: RosettaSupportedKeyPair,
+    {
+        let register_vote_operations = RosettaClient::build_register_vote_operations(
+            signer_keypair.generate_principal_id()?.0,
+            register_vote_args.neuron_index.unwrap_or(0),
+            register_vote_args.proposal,
+            register_vote_args.vote,
+        )
+        .await?;
+
+        self.make_submit_and_wait_for_transaction(
+            signer_keypair,
+            network_identifier,
+            register_vote_operations,
+            None,
+            None,
+        )
+        .await
+    }
+
+    // Retrieves the list of proposals that are currently pending.
+    pub async fn get_pending_proposals(
+        &self,
+        network_identifier: NetworkIdentifier,
+    ) -> anyhow::Result<Vec<Proposal>, String> {
+        let response = self
+            .call(CallRequest::new(
+                network_identifier.clone(),
+                "get_pending_proposals".to_owned(),
+                ObjectMap::new(),
+            ))
+            .await
+            .unwrap();
+
+        let pending_proposals: Vec<Proposal> =
+            PendingProposalsResponse::try_from(Some(response.result))
+                .unwrap()
+                .pending_proposals
+                .into_iter()
+                .map(|p| p.proposal.unwrap())
+                .collect();
+
+        Ok(pending_proposals)
+    }
+
     /// A neuron can be set to automatically restake its maturity.
     pub async fn change_auto_stake_maturity<T>(
         &self,
@@ -1536,6 +1623,47 @@ impl RosettaSetNeuronDissolveDelayArgsBuilder {
     }
 }
 
+pub struct RosettaRegisterVoteArgs {
+    pub neuron_index: Option<u64>,
+    pub proposal: u64,
+    pub vote: i32,
+}
+
+impl RosettaRegisterVoteArgs {
+    pub fn builder(proposal: u64, vote: i32) -> RosettaRegisterVoteArgsBuilder {
+        RosettaRegisterVoteArgsBuilder::new(proposal, vote)
+    }
+}
+
+pub struct RosettaRegisterVoteArgsBuilder {
+    proposal: u64,
+    vote: i32,
+    neuron_index: Option<u64>,
+}
+
+impl RosettaRegisterVoteArgsBuilder {
+    pub fn new(proposal: u64, vote: i32) -> Self {
+        Self {
+            proposal,
+            vote,
+            neuron_index: None,
+        }
+    }
+
+    pub fn with_neuron_index(mut self, neuron_index: u64) -> Self {
+        self.neuron_index = Some(neuron_index);
+        self
+    }
+
+    pub fn build(self) -> RosettaRegisterVoteArgs {
+        RosettaRegisterVoteArgs {
+            proposal: self.proposal,
+            vote: self.vote,
+            neuron_index: self.neuron_index,
+        }
+    }
+}
+
 pub struct RosettaIncreaseNeuronStakeArgs {
     pub neuron_index: Option<u64>,
     pub additional_stake: Nat,

rs/rosetta-api/icp/client/src/lib.rs

@@ -0,0 +1,111 @@
+use candid::{Decode, Encode, Principal};
+use ic_agent::Agent;
+use ic_base_types::PrincipalId;
+use ic_nns_common::{pb::v1::ProposalId, types::NeuronId};
+use ic_nns_governance_api::pb::v1::Motion;
+use ic_nns_governance_api::pb::v1::ProposalActionRequest;
+use ic_nns_governance_api::{
+    pb::v1::{
+        manage_neuron_response, manage_neuron_response::MakeProposalResponse, MakeProposalRequest,
+        ManageNeuronResponse, ProposalInfo,
+    },
+    proposal_submission_helpers::create_make_proposal_payload,
+};
+
+pub struct GovernanceClient {
+    agent: Agent,
+    governance_principal: Principal,
+}
+
+impl GovernanceClient {
+    pub fn new(agent: Agent, governance_principal: Principal) -> GovernanceClient {
+        GovernanceClient {
+            agent,
+            governance_principal,
+        }
+    }
+
+    pub async fn submit_proposal(
+        &self,
+        principal: Principal,
+        neuron_id: NeuronId,
+        title: &str,
+        summary: &str,
+        motion_text: &str,
+    ) -> ProposalId {
+        let proposal = MakeProposalRequest {
+            title: Some(title.to_string()),
+            summary: summary.to_string(),
+            action: Some(ProposalActionRequest::Motion(Motion {
+                motion_text: motion_text.to_string(),
+            })),
+            ..Default::default()
+        };
+
+        let neuron_controller = PrincipalId::from(principal);
+
+        let manage_neuron = create_make_proposal_payload(proposal.clone(), &neuron_id);
+        let arg = Encode!(&manage_neuron).expect("Error while encoding arg.");
+        let res = self
+            .agent
+            .update(&self.governance_principal, "manage_neuron")
+            .with_arg(arg)
+            .call_and_wait()
+            .await
+            .expect("Error while calling endpoint.");
+        //Make sure that the one making the proposal is also the controller of the neuron
+        assert_eq!(
+            PrincipalId::from(self.agent.get_principal().unwrap()),
+            neuron_controller
+        );
+        let manage_neuron_res =
+            Decode!(res.as_slice(), ManageNeuronResponse).expect("Error while decoding response.");
+        if let ManageNeuronResponse {
+            command:
+                Some(manage_neuron_response::Command::MakeProposal(MakeProposalResponse {
+                    proposal_id,
+                    ..
+                })),
+        } = manage_neuron_res
+        {
+            assert!(proposal_id.is_some());
+            let arg = Encode!(&proposal_id.unwrap().id).expect("Error while encoding arg.");
+            self.agent
+                .query(&self.governance_principal, "get_proposal_info")
+                .with_arg(arg)
+                .call()
+                .await
+                .expect("Error while calling endpoint.");
+            proposal_id.unwrap()
+        } else {
+            panic!(
+                "Making Proposal was unsuccessful --> Response : {:?}",
+                manage_neuron_res
+            )
+        }
+    }
+
+    pub async fn get_pending_proposals(&self) -> Vec<ProposalInfo> {
+        let arg = Encode!(&"").expect("Error while encoding arg.");
+        let res = self
+            .agent
+            .query(&self.governance_principal, "get_pending_proposals")
+            .with_arg(arg)
+            .call()
+            .await
+            .expect("Error while calling endpoint.");
+        Decode!(res.as_slice(), Vec<ProposalInfo>).expect("Error while decoding response.")
+    }
+
+    pub async fn get_proposal_info(&self, proposal_id: ProposalId) -> Option<ProposalInfo> {
+        let arg = Encode!(&proposal_id.id).expect("Error while encoding arg.");
+        let res = self
+            .agent
+            .query(&self.governance_principal, "get_proposal_info")
+            .with_arg(arg)
+            .call()
+            .await
+            .expect("Error while calling endpoint.");
+        Decode!(res.as_slice(), Option<ProposalInfo>).expect("Error while decoding response.")
+    }
+}

rs/rosetta-api/icp/tests/system_tests/common/governance_client.rs

@@ -1,3 +1,4 @@
 pub mod constants;
+pub mod governance_client;
 pub mod system_test_environment;
 pub mod utils;

rs/rosetta-api/icp/tests/system_tests/common/mod.rs

@@ -1,3 +1,4 @@
+use super::utils::memo_bytebuf_to_u64;
 use crate::common::utils::get_custom_agent;
 use crate::common::utils::get_test_agent;
 use crate::common::utils::wait_for_rosetta_to_catch_up_with_icp_ledger;
@@ -6,7 +7,7 @@ use crate::common::{
     utils::test_identity,
 };
 use candid::{Encode, Principal};
-use ic_agent::Identity;
+use ic_agent::{Agent, Identity};
 use ic_icp_rosetta_client::RosettaClient;
 use ic_icp_rosetta_client::RosettaTransferArgs;
 use ic_icp_rosetta_runner::RosettaOptions;
@@ -41,8 +42,6 @@ use rosetta_core::identifiers::NetworkIdentifier;
 use std::collections::HashMap;
 use tempfile::TempDir;
 
-use super::utils::memo_bytebuf_to_u64;
-
 pub struct RosettaTestingEnvironment {
     pub pocket_ic: PocketIc,
     pub rosetta_context: RosettaContext,
@@ -154,6 +153,10 @@ impl RosettaTestingEnvironment {
         .await;
         self
     }
+
+    pub async fn get_test_agent(&self) -> Agent {
+        get_test_agent(self.pocket_ic.url().unwrap().port().unwrap()).await
+    }
 }
 
 pub struct RosettaTestingEnvironmentBuilder {

rs/rosetta-api/icp/tests/system_tests/common/system_test_environment.rs

@@ -7,3 +7,4 @@ pub mod network;
 pub mod neuron_management;
 pub mod search_transactions;
 pub mod transfers;
+pub mod voting;