missing implementations of signing methods

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<Coin>,
     ) -> Result<ExecuteResult, NyxdError>;
+
+    async fn update_admin(
+        &self,
+        admin: Option<String>,
+        fee: Option<Fee>,
+    ) -> Result<ExecuteResult, NyxdError> {
+        self.execute_group_contract(
+            fee,
+            GroupExecuteMsg::UpdateAdmin { admin },
+            "GroupExecuteMsg::UpdateAdmin".to_string(),
+            vec![],
+        )
+        .await
+    }
+
+    async fn update_members(
+        &self,
+        add: Vec<Member>,
+        remove: Vec<String>,
+        fee: Option<Fee>,
+    ) -> Result<ExecuteResult, NyxdError> {
+        self.execute_group_contract(
+            fee,
+            GroupExecuteMsg::UpdateMembers { add, remove },
+            "GroupExecuteMsg::UpdateMembers".to_string(),
+            vec![],
+        )
+        .await
+    }
+
+    async fn add_hook(&self, addr: String, fee: Option<Fee>) -> Result<ExecuteResult, NyxdError> {
+        self.execute_group_contract(
+            fee,
+            GroupExecuteMsg::AddHook { addr },
+            "GroupExecuteMsg::AddHook".to_string(),
+            vec![],
+        )
+        .await
+    }
+
+    async fn remove_hook(
+        &self,
+        addr: String,
+        fee: Option<Fee>,
+    ) -> Result<ExecuteResult, NyxdError> {
+        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<C: GroupSigningClient + Send + Sync>(
+    #[allow(dead_code)]
+    fn all_execute_variants_are_covered<C: GroupSigningClient + Send + Sync>(
         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(),
+        };
     }
 }

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<Fee>,
+    ) -> Result<ExecuteResult, NyxdError> {
+        self.execute_mixnet_contract(
+            fee,
+            MixnetExecuteMsg::AssignNodeLayer { mix_id, layer },
+            vec![],
+        )
+        .await
+    }
+
     async fn reconcile_epoch_events(
         &self,
         limit: Option<u32>,
@@ -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<Fee>,
+    ) -> Result<ExecuteResult, NyxdError> {
+        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<C: MixnetSigningClient + Send + Sync>(
+    #[allow(dead_code)]
+    fn all_execute_variants_are_covered<C: MixnetSigningClient + Send + Sync>(
         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()
+            }
+        };
     }
 }

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<Fee>,
+    ) -> Result<ExecuteResult, NyxdError> {
+        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<Fee>,
+    ) -> Result<ExecuteResult, NyxdError> {
+        self.execute_multisig_contract(
+            fee,
+            MultisigExecuteMsg::Close { proposal_id },
+            "Multisig::Close".to_string(),
+            vec![],
+        )
+        .await
+    }
+
+    async fn changed_member_hook(
+        &self,
+        member_diff: Vec<MemberDiff>,
+        fee: Option<Fee>,
+    ) -> Result<ExecuteResult, NyxdError> {
+        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<C: MultisigSigningClient + Send + Sync>(
+    #[allow(dead_code)]
+    fn all_execute_variants_are_covered<C: MultisigSigningClient + Send + Sync>(
         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()
+            }
+        };
     }
 }

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<C: NameServiceSigningClient + Send + Sync>(
+    #[allow(dead_code)]
+    fn all_execute_variants_are_covered<C: NameServiceSigningClient + Send + Sync>(
         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(),
+        };
     }
 }

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<C: SpDirectorySigningClient + Send + Sync>(
+    #[allow(dead_code)]
+    fn all_execute_variants_are_covered<C: SpDirectorySigningClient + Send + Sync>(
         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(),
+        };
     }
 }

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<Fee>,
+    ) -> Result<ExecuteResult, NyxdError> {
+        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<Fee>,
+    ) -> Result<ExecuteResult, NyxdError> {
+        self.execute_vesting_contract(
+            fee,
+            VestingExecuteMsg::TrackReward {
+                amount: amount.into(),
+                address,
+            },
+            Vec::new(),
+        )
+        .await
+    }
+
     async fn vesting_withdraw_operator_reward(
         &self,
         fee: Option<Fee>,
@@ -277,6 +311,32 @@ pub trait VestingSigningClient {
         .await
     }
 
+    async fn vesting_transfer_ownership(
+        &self,
+        to_address: String,
+        fee: Option<Fee>,
+    ) -> Result<ExecuteResult, NyxdError> {
+        self.execute_vesting_contract(
+            fee,
+            VestingExecuteMsg::TransferOwnership { to_address },
+            Vec::new(),
+        )
+        .await
+    }
+
+    async fn update_staking_address(
+        &self,
+        to_address: Option<String>,
+        fee: Option<Fee>,
+    ) -> Result<ExecuteResult, NyxdError> {
+        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<C: VestingSigningClient + Send + Sync>(
+    #[allow(dead_code)]
+    fn all_execute_variants_are_covered<C: VestingSigningClient + Send + Sync>(
         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(),
+        };
     }
 }