feat(minor-service-registry): use coordinator client

axelarnetwork · Sep 10, 2024 · 65f8691 · 65f8691
1 parent a58c3ac
commit 65f8691
Show file tree

Hide file tree

Showing 3 changed files with 48 additions and 24 deletions.
diff --git a/contracts/service-registry/src/contract.rs b/contracts/service-registry/src/contract.rs
@@ -2,8 +2,8 @@ use axelar_wasm_std::{address, permission_control, FnExt};
 #[cfg(not(feature = "library"))]
 use cosmwasm_std::entry_point;
 use cosmwasm_std::{
-    to_json_binary, Addr, BankMsg, Binary, Coin, Deps, DepsMut, Empty, Env, MessageInfo,
-    QueryRequest, Response, Storage, WasmQuery,
+    to_json_binary, Addr, BankMsg, Binary, Coin, Deps, DepsMut, Empty, Env, MessageInfo, Response,
+    Storage,
 };
 use error_stack::{bail, Report, ResultExt};
 
@@ -190,7 +190,9 @@ mod test {
     use cosmwasm_std::testing::{
         mock_dependencies, mock_env, mock_info, MockApi, MockQuerier, MockStorage,
     };
-    use cosmwasm_std::{coins, from_json, CosmosMsg, Empty, OwnedDeps, StdResult, Uint128};
+    use cosmwasm_std::{
+        coins, from_json, CosmosMsg, Empty, OwnedDeps, StdResult, Uint128, WasmQuery,
+    };
     use router_api::ChainName;
 
     use super::*;

diff --git a/contracts/service-registry/src/contract/execute.rs b/contracts/service-registry/src/contract/execute.rs
@@ -1,4 +1,5 @@
 use axelar_wasm_std::nonempty;
+use error_stack::Result;
 use router_api::ChainName;
 
 use super::*;
@@ -21,7 +22,7 @@ pub fn register_service(
     SERVICES.update(
         deps.storage,
         key,
-        |service| -> Result<Service, ContractError> {
+        |service| -> std::result::Result<Service, ContractError> {
             match service {
                 None => Ok(Service {
                     name: service_name,
@@ -49,14 +50,15 @@ pub fn update_verifier_authorization_status(
     auth_state: AuthorizationState,
 ) -> Result<Response, ContractError> {
     SERVICES
-        .may_load(deps.storage, &service_name)?
+        .may_load(deps.storage, &service_name)
+        .change_context(ContractError::StorageError)?
         .ok_or(ContractError::ServiceNotFound)?;
 
     for verifier in verifiers {
         VERIFIERS.update(
             deps.storage,
             (&service_name, &verifier.clone()),
-            |sw| -> Result<Verifier, ContractError> {
+            |sw| -> std::result::Result<Verifier, ContractError> {
                 match sw {
                     Some(mut verifier) => {
                         verifier.authorization_state = auth_state.clone();
@@ -82,7 +84,8 @@ pub fn bond_verifier(
     service_name: String,
 ) -> Result<Response, ContractError> {
     let service = SERVICES
-        .may_load(deps.storage, &service_name)?
+        .may_load(deps.storage, &service_name)
+        .change_context(ContractError::StorageError)?
         .ok_or(ContractError::ServiceNotFound)?;
 
     let bond: Option<nonempty::Uint128> = if !info.funds.is_empty() {
@@ -92,7 +95,8 @@ pub fn bond_verifier(
                 .find(|coin| coin.denom == service.bond_denom)
                 .ok_or(ContractError::WrongDenom)?
                 .amount
-                .try_into()?,
+                .try_into()
+                .map_err(ContractError::from)?,
         )
     } else {
         None // sender can rebond currently unbonding funds by just sending no new funds
@@ -101,7 +105,7 @@ pub fn bond_verifier(
     VERIFIERS.update(
         deps.storage,
         (&service_name.clone(), &info.sender.clone()),
-        |sw| -> Result<Verifier, ContractError> {
+        |sw| -> std::result::Result<Verifier, ContractError> {
             match sw {
                 Some(verifier) => Ok(verifier.bond(bond)?),
                 None => Ok(Verifier {
@@ -126,7 +130,8 @@ pub fn register_chains_support(
     chains: Vec<ChainName>,
 ) -> Result<Response, ContractError> {
     SERVICES
-        .may_load(deps.storage, &service_name)?
+        .may_load(deps.storage, &service_name)
+        .change_context(ContractError::StorageError)?
         .ok_or(ContractError::ServiceNotFound)?;
 
     state::register_chains_support(
@@ -146,7 +151,8 @@ pub fn deregister_chains_support(
     chains: Vec<ChainName>,
 ) -> Result<Response, ContractError> {
     SERVICES
-        .may_load(deps.storage, &service_name)?
+        .may_load(deps.storage, &service_name)
+        .change_context(ContractError::StorageError)?
         .ok_or(ContractError::ServiceNotFound)?;
 
     state::deregister_chains_support(deps.storage, service_name.clone(), chains, info.sender)?;
@@ -161,24 +167,27 @@ pub fn unbond_verifier(
     service_name: String,
 ) -> Result<Response, ContractError> {
     let service = SERVICES
-        .may_load(deps.storage, &service_name)?
+        .may_load(deps.storage, &service_name)
+        .change_context(ContractError::StorageError)?
         .ok_or(ContractError::ServiceNotFound)?;
 
     let verifier = VERIFIERS
-        .may_load(deps.storage, (&service_name, &info.sender))?
+        .may_load(deps.storage, (&service_name, &info.sender))
+        .change_context(ContractError::StorageError)?
         .ok_or(ContractError::VerifierNotFound)?;
 
-    let query = coordinator::msg::QueryMsg::ReadyToUnbond {
-        worker_address: verifier.address.clone(),
-    };
-    let ready_to_unbond = deps.querier.query(&QueryRequest::Wasm(WasmQuery::Smart {
-        contract_addr: service.coordinator_contract.into(),
-        msg: to_json_binary(&query)?,
-    }))?;
+    let coordinator: coordinator::client::Client =
+        client::Client::new(deps.querier, &service.coordinator_contract).into();
+
+    let ready_to_unbond = coordinator
+        .ready_to_unbond(verifier.address.clone())
+        .change_context(ContractError::FailedToUnbondVerifier)?;
 
     let verifier = verifier.unbond(ready_to_unbond, env.block.time)?;
 
-    VERIFIERS.save(deps.storage, (&service_name, &info.sender), &verifier)?;
+    VERIFIERS
+        .save(deps.storage, (&service_name, &info.sender), &verifier)
+        .change_context(ContractError::StorageError)?;
 
     Ok(Response::new())
 }
@@ -190,17 +199,21 @@ pub fn claim_stake(
     service_name: String,
 ) -> Result<Response, ContractError> {
     let service = SERVICES
-        .may_load(deps.storage, &service_name)?
+        .may_load(deps.storage, &service_name)
+        .change_context(ContractError::StorageError)?
         .ok_or(ContractError::ServiceNotFound)?;
 
     let verifier = VERIFIERS
-        .may_load(deps.storage, (&service_name, &info.sender))?
+        .may_load(deps.storage, (&service_name, &info.sender))
+        .change_context(ContractError::StorageError)?
         .ok_or(ContractError::VerifierNotFound)?;
 
     let (verifier, released_bond) =
         verifier.claim_stake(env.block.time, service.unbonding_period_days as u64)?;
 
-    VERIFIERS.save(deps.storage, (&service_name, &info.sender), &verifier)?;
+    VERIFIERS
+        .save(deps.storage, (&service_name, &info.sender), &verifier)
+        .change_context(ContractError::StorageError)?;
 
     Ok(Response::new().add_message(BankMsg::Send {
         to_address: info.sender.into(),

diff --git a/contracts/service-registry/src/error.rs b/contracts/service-registry/src/error.rs
@@ -35,4 +35,13 @@ pub enum ContractError {
     NotEnoughVerifiers,
     #[error("verifier is jailed")]
     VerifierJailed,
+    #[error("failed to unbond verifier")]
+    FailedToUnbondVerifier,
+
+    // Generic error to wrap cw_storage_plus errors
+    // This should only be used for things that shouldn't happen, such as encountering
+    // an error when loading data that should load successfully. For errors that can
+    // happen in the normal course of things, use a more descriptive error
+    #[error("storage error")]
+    StorageError,
 }