diff --git a/common/client-libs/validator-client/src/nyxd/contract_traits/group_signing_client.rs b/common/client-libs/validator-client/src/nyxd/contract_traits/group_signing_client.rs index af05635430..07d14200d7 100644 --- a/common/client-libs/validator-client/src/nyxd/contract_traits/group_signing_client.rs +++ b/common/client-libs/validator-client/src/nyxd/contract_traits/group_signing_client.rs @@ -7,6 +7,7 @@ use crate::nyxd::error::NyxdError; use crate::nyxd::{Coin, Fee, SigningCosmWasmClient}; use crate::signing::signer::OfflineSigner; use async_trait::async_trait; +use cw4::Member; use nym_group_contract_common::msg::ExecuteMsg as GroupExecuteMsg; #[async_trait] @@ -18,6 +19,59 @@ pub trait GroupSigningClient { memo: String, funds: Vec, ) -> Result; + + async fn update_admin( + &self, + admin: Option, + fee: Option, + ) -> Result { + self.execute_group_contract( + fee, + GroupExecuteMsg::UpdateAdmin { admin }, + "GroupExecuteMsg::UpdateAdmin".to_string(), + vec![], + ) + .await + } + + async fn update_members( + &self, + add: Vec, + remove: Vec, + fee: Option, + ) -> Result { + self.execute_group_contract( + fee, + GroupExecuteMsg::UpdateMembers { add, remove }, + "GroupExecuteMsg::UpdateMembers".to_string(), + vec![], + ) + .await + } + + async fn add_hook(&self, addr: String, fee: Option) -> Result { + self.execute_group_contract( + fee, + GroupExecuteMsg::AddHook { addr }, + "GroupExecuteMsg::AddHook".to_string(), + vec![], + ) + .await + } + + async fn remove_hook( + &self, + addr: String, + fee: Option, + ) -> Result { + self.execute_group_contract( + fee, + GroupExecuteMsg::RemoveHook { addr }, + "GroupExecuteMsg::RemoveHook".to_string(), + vec![], + ) + .await + } } #[async_trait] @@ -55,12 +109,21 @@ where #[cfg(test)] mod tests { use super::*; + use crate::nyxd::contract_traits::tests::IgnoreValue; // it's enough that this compiles and clippy is happy about it - async fn all_execute_variants_are_covered( + #[allow(dead_code)] + fn all_execute_variants_are_covered( client: C, msg: GroupExecuteMsg, ) { - unimplemented!() + match msg { + GroupExecuteMsg::UpdateAdmin { admin } => client.update_admin(admin, None).ignore(), + GroupExecuteMsg::UpdateMembers { remove, add } => { + client.update_members(add, remove, None).ignore() + } + GroupExecuteMsg::AddHook { addr } => client.add_hook(addr, None).ignore(), + GroupExecuteMsg::RemoveHook { addr } => client.remove_hook(addr, None).ignore(), + }; } } diff --git a/common/client-libs/validator-client/src/nyxd/contract_traits/mixnet_signing_client.rs b/common/client-libs/validator-client/src/nyxd/contract_traits/mixnet_signing_client.rs index de5923a5a1..ad7d03327c 100644 --- a/common/client-libs/validator-client/src/nyxd/contract_traits/mixnet_signing_client.rs +++ b/common/client-libs/validator-client/src/nyxd/contract_traits/mixnet_signing_client.rs @@ -15,7 +15,8 @@ use nym_mixnet_contract_common::gateway::GatewayConfigUpdate; use nym_mixnet_contract_common::mixnode::{MixNodeConfigUpdate, MixNodeCostParams}; use nym_mixnet_contract_common::reward_params::{IntervalRewardingParamsUpdate, Performance}; use nym_mixnet_contract_common::{ - ContractStateParams, ExecuteMsg as MixnetExecuteMsg, Gateway, LayerAssignment, MixId, MixNode, + ContractStateParams, ExecuteMsg as MixnetExecuteMsg, Gateway, Layer, LayerAssignment, MixId, + MixNode, }; #[async_trait] @@ -132,6 +133,20 @@ pub trait MixnetSigningClient { .await } + async fn assign_node_layer( + &self, + mix_id: MixId, + layer: Layer, + fee: Option, + ) -> Result { + self.execute_mixnet_contract( + fee, + MixnetExecuteMsg::AssignNodeLayer { mix_id, layer }, + vec![], + ) + .await + } + async fn reconcile_epoch_events( &self, limit: Option, @@ -666,6 +681,18 @@ pub trait MixnetSigningClient { ) .await } + + #[cfg(feature = "nym_mixnet_contract_common/contract-testing")] + async fn testing_resolve_all_pending_events( + fee: Option, + ) -> Result { + self.execute_mixnet_contract( + fee, + MixnetExecuteMsg::TestingResolveAllPendingEvents {}, + vec![], + ) + .await + } } #[async_trait] @@ -703,12 +730,206 @@ where #[cfg(test)] mod tests { use super::*; + use crate::nyxd::contract_traits::tests::{mock_coin, IgnoreValue}; // it's enough that this compiles and clippy is happy about it - async fn all_execute_variants_are_covered( + #[allow(dead_code)] + fn all_execute_variants_are_covered( client: C, msg: MixnetExecuteMsg, ) { - unimplemented!() + match msg { + MixnetExecuteMsg::AssignNodeLayer { mix_id, layer } => { + client.assign_node_layer(mix_id, layer, None).ignore() + } + MixnetExecuteMsg::CreateFamily { label } => client.create_family(label, None).ignore(), + MixnetExecuteMsg::JoinFamily { + join_permit, + family_head, + } => client.join_family(join_permit, family_head, None).ignore(), + MixnetExecuteMsg::LeaveFamily { family_head } => { + client.leave_family(family_head, None).ignore() + } + MixnetExecuteMsg::KickFamilyMember { member } => { + client.kick_family_member(member, None).ignore() + } + MixnetExecuteMsg::CreateFamilyOnBehalf { + owner_address, + label, + } => client + .create_family_on_behalf(owner_address, label, None) + .ignore(), + MixnetExecuteMsg::JoinFamilyOnBehalf { + member_address, + join_permit, + family_head, + } => client + .join_family_on_behalf(member_address, join_permit, family_head, None) + .ignore(), + MixnetExecuteMsg::LeaveFamilyOnBehalf { + member_address, + family_head, + } => client + .leave_family_on_behalf(member_address, family_head, None) + .ignore(), + MixnetExecuteMsg::KickFamilyMemberOnBehalf { + head_address, + member, + } => client + .kick_family_member_on_behalf(head_address, member, None) + .ignore(), + MixnetExecuteMsg::UpdateRewardingValidatorAddress { address } => client + .update_rewarding_validator_address(address.parse().unwrap(), None) + .ignore(), + MixnetExecuteMsg::UpdateContractStateParams { updated_parameters } => client + .update_contract_state_params(updated_parameters, None) + .ignore(), + MixnetExecuteMsg::UpdateActiveSetSize { + active_set_size, + force_immediately, + } => client + .update_active_set_size(active_set_size, force_immediately, None) + .ignore(), + MixnetExecuteMsg::UpdateRewardingParams { + updated_params, + force_immediately, + } => client + .update_rewarding_parameters(updated_params, force_immediately, None) + .ignore(), + MixnetExecuteMsg::UpdateIntervalConfig { + epochs_in_interval, + epoch_duration_secs, + force_immediately, + } => client + .update_interval_config( + epochs_in_interval, + epoch_duration_secs, + force_immediately, + None, + ) + .ignore(), + MixnetExecuteMsg::BeginEpochTransition {} => { + client.begin_epoch_transition(None).ignore() + } + MixnetExecuteMsg::AdvanceCurrentEpoch { + new_rewarded_set, + expected_active_set_size, + } => client + .advance_current_epoch(new_rewarded_set, expected_active_set_size, None) + .ignore(), + MixnetExecuteMsg::ReconcileEpochEvents { limit } => { + client.reconcile_epoch_events(limit, None).ignore() + } + MixnetExecuteMsg::BondMixnode { + mix_node, + cost_params, + owner_signature, + } => client + .bond_mixnode(mix_node, cost_params, owner_signature, mock_coin(), None) + .ignore(), + MixnetExecuteMsg::BondMixnodeOnBehalf { + mix_node, + cost_params, + owner_signature, + owner, + } => client + .bond_mixnode_on_behalf( + owner.parse().unwrap(), + mix_node, + cost_params, + owner_signature, + mock_coin(), + None, + ) + .ignore(), + MixnetExecuteMsg::PledgeMore {} => client.pledge_more(mock_coin(), None).ignore(), + MixnetExecuteMsg::PledgeMoreOnBehalf { owner } => client + .pledge_more_on_behalf(owner.parse().unwrap(), mock_coin(), None) + .ignore(), + MixnetExecuteMsg::DecreasePledge { decrease_by } => { + client.decrease_pledge(decrease_by.into(), None).ignore() + } + MixnetExecuteMsg::DecreasePledgeOnBehalf { owner, decrease_by } => client + .decrease_pledge_on_behalf(owner.parse().unwrap(), decrease_by.into(), None) + .ignore(), + MixnetExecuteMsg::UnbondMixnode {} => client.unbond_mixnode(None).ignore(), + MixnetExecuteMsg::UnbondMixnodeOnBehalf { owner } => client + .unbond_mixnode_on_behalf(owner.parse().unwrap(), None) + .ignore(), + MixnetExecuteMsg::UpdateMixnodeCostParams { new_costs } => { + client.update_mixnode_cost_params(new_costs, None).ignore() + } + MixnetExecuteMsg::UpdateMixnodeCostParamsOnBehalf { new_costs, owner } => client + .update_mixnode_cost_params_on_behalf(owner.parse().unwrap(), new_costs, None) + .ignore(), + MixnetExecuteMsg::UpdateMixnodeConfig { new_config } => { + client.update_mixnode_config(new_config, None).ignore() + } + MixnetExecuteMsg::UpdateMixnodeConfigOnBehalf { new_config, owner } => client + .update_mixnode_config_on_behalf(owner.parse().unwrap(), new_config, None) + .ignore(), + MixnetExecuteMsg::BondGateway { + gateway, + owner_signature, + } => client + .bond_gateway(gateway, owner_signature, mock_coin(), None) + .ignore(), + MixnetExecuteMsg::BondGatewayOnBehalf { + gateway, + owner, + owner_signature, + } => client + .bond_gateway_on_behalf( + owner.parse().unwrap(), + gateway, + owner_signature, + mock_coin(), + None, + ) + .ignore(), + MixnetExecuteMsg::UnbondGateway {} => client.unbond_gateway(None).ignore(), + MixnetExecuteMsg::UnbondGatewayOnBehalf { owner } => client + .unbond_gateway_on_behalf(owner.parse().unwrap(), None) + .ignore(), + MixnetExecuteMsg::UpdateGatewayConfig { new_config } => { + client.update_gateway_config(new_config, None).ignore() + } + MixnetExecuteMsg::UpdateGatewayConfigOnBehalf { new_config, owner } => client + .update_gateway_config_on_behalf(owner.parse().unwrap(), new_config, None) + .ignore(), + MixnetExecuteMsg::DelegateToMixnode { mix_id } => client + .delegate_to_mixnode(mix_id, mock_coin(), None) + .ignore(), + MixnetExecuteMsg::DelegateToMixnodeOnBehalf { mix_id, delegate } => client + .delegate_to_mixnode_on_behalf(delegate.parse().unwrap(), mix_id, mock_coin(), None) + .ignore(), + MixnetExecuteMsg::UndelegateFromMixnode { mix_id } => { + client.undelegate_from_mixnode(mix_id, None).ignore() + } + MixnetExecuteMsg::UndelegateFromMixnodeOnBehalf { mix_id, delegate } => client + .undelegate_to_mixnode_on_behalf(delegate.parse().unwrap(), mix_id, None) + .ignore(), + MixnetExecuteMsg::RewardMixnode { + mix_id, + performance, + } => client.reward_mixnode(mix_id, performance, None).ignore(), + MixnetExecuteMsg::WithdrawOperatorReward {} => { + client.withdraw_operator_reward(None).ignore() + } + MixnetExecuteMsg::WithdrawOperatorRewardOnBehalf { owner } => client + .withdraw_operator_reward_on_behalf(owner.parse().unwrap(), None) + .ignore(), + MixnetExecuteMsg::WithdrawDelegatorReward { mix_id } => { + client.withdraw_delegator_reward(mix_id, None).ignore() + } + MixnetExecuteMsg::WithdrawDelegatorRewardOnBehalf { mix_id, owner } => client + .withdraw_delegator_reward_on_behalf(owner.parse().unwrap(), mix_id, None) + .ignore(), + + #[cfg(feature = "nym_mixnet_contract_common/contract-testing")] + MixnetExecuteMsg::TestingResolveAllPendingEvents {} => { + client.testing_resolve_all_pending_events(None).ignore() + } + }; } } diff --git a/common/client-libs/validator-client/src/nyxd/contract_traits/multisig_signing_client.rs b/common/client-libs/validator-client/src/nyxd/contract_traits/multisig_signing_client.rs index 9e6c2948db..0da2fd9de8 100644 --- a/common/client-libs/validator-client/src/nyxd/contract_traits/multisig_signing_client.rs +++ b/common/client-libs/validator-client/src/nyxd/contract_traits/multisig_signing_client.rs @@ -9,6 +9,7 @@ use crate::signing::signer::OfflineSigner; use async_trait::async_trait; use cosmwasm_std::{to_binary, CosmosMsg, WasmMsg}; use cw3::Vote; +use cw4::{MemberChangedHookMsg, MemberDiff}; use nym_coconut_bandwidth_contract_common::msg::ExecuteMsg as CoconutBandwidthExecuteMsg; use nym_multisig_contract_common::msg::ExecuteMsg as MultisigExecuteMsg; @@ -68,6 +69,22 @@ pub trait MultisigSigningClient: NymContractsProvider { .await } + // alternative variant to vote_proposal that lets you to abstain and veto a proposal + async fn vote( + &self, + proposal_id: u64, + vote: Vote, + fee: Option, + ) -> Result { + self.execute_multisig_contract( + fee, + MultisigExecuteMsg::Vote { proposal_id, vote }, + "Multisig::Vote".to_string(), + vec![], + ) + .await + } + async fn execute_proposal( &self, proposal_id: u64, @@ -77,6 +94,34 @@ pub trait MultisigSigningClient: NymContractsProvider { self.execute_multisig_contract(fee, req, "Multisig::Execute".to_string(), vec![]) .await } + + async fn close_proposal( + &self, + proposal_id: u64, + fee: Option, + ) -> Result { + self.execute_multisig_contract( + fee, + MultisigExecuteMsg::Close { proposal_id }, + "Multisig::Close".to_string(), + vec![], + ) + .await + } + + async fn changed_member_hook( + &self, + member_diff: Vec, + fee: Option, + ) -> Result { + self.execute_multisig_contract( + fee, + MultisigExecuteMsg::MemberChangedHook(MemberChangedHookMsg::new(member_diff)), + "Multisig::MemberChangedHook".to_string(), + vec![], + ) + .await + } } #[async_trait] @@ -114,12 +159,32 @@ where #[cfg(test)] mod tests { use super::*; + use crate::nyxd::contract_traits::tests::{mock_coin, IgnoreValue}; // it's enough that this compiles and clippy is happy about it - async fn all_execute_variants_are_covered( + #[allow(dead_code)] + fn all_execute_variants_are_covered( client: C, msg: MultisigExecuteMsg, ) { - unimplemented!() + match msg { + MultisigExecuteMsg::Propose { + title, description, .. + } => client + .propose_release_funds(title, description, mock_coin(), None) + .ignore(), + MultisigExecuteMsg::Vote { proposal_id, vote } => { + client.vote(proposal_id, vote, None).ignore() + } + MultisigExecuteMsg::Execute { proposal_id } => { + client.execute_proposal(proposal_id, None).ignore() + } + MultisigExecuteMsg::Close { proposal_id } => { + client.close_proposal(proposal_id, None).ignore() + } + MultisigExecuteMsg::MemberChangedHook(hook_msg) => { + client.changed_member_hook(hook_msg.diffs, None).ignore() + } + }; } } diff --git a/common/client-libs/validator-client/src/nyxd/contract_traits/name_service_signing_client.rs b/common/client-libs/validator-client/src/nyxd/contract_traits/name_service_signing_client.rs index 27ff60c99a..bc5a06e1a9 100644 --- a/common/client-libs/validator-client/src/nyxd/contract_traits/name_service_signing_client.rs +++ b/common/client-libs/validator-client/src/nyxd/contract_traits/name_service_signing_client.rs @@ -107,12 +107,30 @@ where #[cfg(test)] mod tests { use super::*; + use crate::nyxd::contract_traits::tests::{mock_coin, IgnoreValue}; // it's enough that this compiles and clippy is happy about it - async fn all_execute_variants_are_covered( + #[allow(dead_code)] + fn all_execute_variants_are_covered( client: C, msg: NameExecuteMsg, ) { - unimplemented!() + match msg { + NameExecuteMsg::Register { + name, + owner_signature, + } => client + .register_name(name, owner_signature, mock_coin(), None) + .ignore(), + NameExecuteMsg::DeleteId { name_id } => { + client.delete_name_by_id(name_id, None).ignore() + } + NameExecuteMsg::DeleteName { name } => { + client.delete_service_provider_by_name(name, None).ignore() + } + NameExecuteMsg::UpdateDepositRequired { deposit_required } => client + .update_deposit_required(deposit_required.into(), None) + .ignore(), + }; } } diff --git a/common/client-libs/validator-client/src/nyxd/contract_traits/sp_directory_signing_client.rs b/common/client-libs/validator-client/src/nyxd/contract_traits/sp_directory_signing_client.rs index 597847549f..9d0f3f458a 100644 --- a/common/client-libs/validator-client/src/nyxd/contract_traits/sp_directory_signing_client.rs +++ b/common/client-libs/validator-client/src/nyxd/contract_traits/sp_directory_signing_client.rs @@ -117,12 +117,30 @@ where #[cfg(test)] mod tests { use super::*; + use crate::nyxd::contract_traits::tests::{mock_coin, IgnoreValue}; // it's enough that this compiles and clippy is happy about it - async fn all_execute_variants_are_covered( + #[allow(dead_code)] + fn all_execute_variants_are_covered( client: C, msg: SpExecuteMsg, ) { - unimplemented!() + match msg { + SpExecuteMsg::Announce { + service, + owner_signature, + } => client + .announce_service_provider(service, owner_signature, mock_coin(), None) + .ignore(), + SpExecuteMsg::DeleteId { service_id } => client + .delete_service_provider_by_id(service_id, None) + .ignore(), + SpExecuteMsg::DeleteNymAddress { nym_address } => client + .delete_service_provider_by_nym_address(nym_address, None) + .ignore(), + SpExecuteMsg::UpdateDepositRequired { deposit_required } => client + .update_deposit_required(deposit_required.into(), None) + .ignore(), + }; } } diff --git a/common/client-libs/validator-client/src/nyxd/contract_traits/vesting_signing_client.rs b/common/client-libs/validator-client/src/nyxd/contract_traits/vesting_signing_client.rs index eff759e068..b540d3b3f9 100644 --- a/common/client-libs/validator-client/src/nyxd/contract_traits/vesting_signing_client.rs +++ b/common/client-libs/validator-client/src/nyxd/contract_traits/vesting_signing_client.rs @@ -71,6 +71,23 @@ pub trait VestingSigningClient { self.execute_vesting_contract(fee, req, vec![]).await } + async fn vesting_track_decrease_pledge( + &self, + owner: String, + amount: Coin, + fee: Option, + ) -> Result { + self.execute_vesting_contract( + fee, + VestingExecuteMsg::TrackDecreasePledge { + owner, + amount: amount.into(), + }, + Vec::new(), + ) + .await + } + async fn vesting_bond_gateway( &self, gateway: Gateway, @@ -256,6 +273,23 @@ pub trait VestingSigningClient { self.execute_vesting_contract(fee, req, vec![amount]).await } + async fn vesting_track_reward( + &self, + amount: Coin, + address: String, + fee: Option, + ) -> Result { + self.execute_vesting_contract( + fee, + VestingExecuteMsg::TrackReward { + amount: amount.into(), + address, + }, + Vec::new(), + ) + .await + } + async fn vesting_withdraw_operator_reward( &self, fee: Option, @@ -277,6 +311,32 @@ pub trait VestingSigningClient { .await } + async fn vesting_transfer_ownership( + &self, + to_address: String, + fee: Option, + ) -> Result { + self.execute_vesting_contract( + fee, + VestingExecuteMsg::TransferOwnership { to_address }, + Vec::new(), + ) + .await + } + + async fn update_staking_address( + &self, + to_address: Option, + fee: Option, + ) -> Result { + self.execute_vesting_contract( + fee, + VestingExecuteMsg::UpdateStakingAddress { to_address }, + Vec::new(), + ) + .await + } + async fn update_locked_pledge_cap( &self, address: AccountId, @@ -374,12 +434,130 @@ where #[cfg(test)] mod tests { use super::*; + use crate::nyxd::contract_traits::tests::{mock_coin, IgnoreValue}; // it's enough that this compiles and clippy is happy about it - async fn all_execute_variants_are_covered( + #[allow(dead_code)] + fn all_execute_variants_are_covered( client: C, msg: VestingExecuteMsg, ) { - unimplemented!() + match msg { + VestingExecuteMsg::CreateFamily { label } => { + client.vesting_create_family(label, None).ignore() + } + VestingExecuteMsg::JoinFamily { + join_permit, + family_head, + } => client + .vesting_join_family(join_permit, family_head, None) + .ignore(), + VestingExecuteMsg::LeaveFamily { family_head } => { + client.vesting_leave_family(family_head, None).ignore() + } + VestingExecuteMsg::KickFamilyMember { member } => { + client.vesting_kick_family_member(member, None).ignore() + } + VestingExecuteMsg::TrackReward { amount, address } => client + .vesting_track_reward(amount.into(), address, None) + .ignore(), + VestingExecuteMsg::ClaimOperatorReward {} => { + client.vesting_withdraw_operator_reward(None).ignore() + } + VestingExecuteMsg::ClaimDelegatorReward { mix_id } => client + .vesting_withdraw_delegator_reward(mix_id, None) + .ignore(), + VestingExecuteMsg::UpdateMixnodeCostParams { new_costs } => client + .vesting_update_mixnode_cost_params(new_costs, None) + .ignore(), + VestingExecuteMsg::UpdateMixnodeConfig { new_config } => client + .vesting_update_mixnode_config(new_config, None) + .ignore(), + VestingExecuteMsg::UpdateMixnetAddress { address } => { + client.update_mixnet_address(&address, None).ignore() + } + VestingExecuteMsg::DelegateToMixnode { + mix_id, + amount, + on_behalf_of, + } => client + .vesting_delegate_to_mixnode(mix_id, amount.into(), on_behalf_of, None) + .ignore(), + VestingExecuteMsg::UndelegateFromMixnode { + mix_id, + on_behalf_of, + } => client + .vesting_undelegate_from_mixnode(mix_id, on_behalf_of, None) + .ignore(), + VestingExecuteMsg::CreateAccount { + owner_address, + staking_address, + vesting_spec, + cap, + } => client + .create_periodic_vesting_account( + &owner_address, + staking_address, + vesting_spec, + mock_coin(), + cap, + None, + ) + .ignore(), + VestingExecuteMsg::WithdrawVestedCoins { amount } => { + client.withdraw_vested_coins(amount.into(), None).ignore() + } + VestingExecuteMsg::TrackUndelegation { + owner, + mix_id, + amount, + } => client + .vesting_track_undelegation(&owner, mix_id, amount.into(), None) + .ignore(), + VestingExecuteMsg::BondMixnode { + mix_node, + cost_params, + owner_signature, + amount, + } => client + .vesting_bond_mixnode(mix_node, cost_params, owner_signature, amount.into(), None) + .ignore(), + VestingExecuteMsg::PledgeMore { amount } => { + client.vesting_pledge_more(amount.into(), None).ignore() + } + VestingExecuteMsg::DecreasePledge { amount } => { + client.vesting_decrease_pledge(amount.into(), None).ignore() + } + VestingExecuteMsg::UnbondMixnode {} => client.vesting_unbond_mixnode(None).ignore(), + VestingExecuteMsg::TrackUnbondMixnode { owner, amount } => client + .vesting_track_unbond_mixnode(&owner, amount.into(), None) + .ignore(), + VestingExecuteMsg::TrackDecreasePledge { owner, amount } => client + .vesting_track_decrease_pledge(owner, amount.into(), None) + .ignore(), + VestingExecuteMsg::BondGateway { + gateway, + owner_signature, + amount, + } => client + .vesting_bond_gateway(gateway, owner_signature, amount.into(), None) + .ignore(), + VestingExecuteMsg::UnbondGateway {} => client.vesting_unbond_gateway(None).ignore(), + VestingExecuteMsg::TrackUnbondGateway { owner, amount } => client + .vesting_track_unbond_gateway(&owner, amount.into(), None) + .ignore(), + VestingExecuteMsg::UpdateGatewayConfig { new_config } => client + .vesting_update_gateway_config(new_config, None) + .ignore(), + VestingExecuteMsg::TransferOwnership { to_address } => { + client.vesting_transfer_ownership(to_address, None).ignore() + } + VestingExecuteMsg::UpdateStakingAddress { to_address } => { + client.update_staking_address(to_address, None).ignore() + } + VestingExecuteMsg::UpdateLockedPledgeCap { address, cap } => client + .update_locked_pledge_cap(address.parse().unwrap(), cap, None) + .ignore(), + }; } }