cw_multi_test/
stargate.rs

1//! # Handler for `CosmosMsg::Stargate`, `CosmosMsg::Any`, `QueryRequest::Stargate` and `QueryRequest::Grpc` messages
2
3use crate::error::AnyResult;
4use crate::{AppResponse, CosmosRouter};
5use anyhow::bail;
6use cosmwasm_std::{
7    to_json_binary, Addr, AnyMsg, Api, Binary, BlockInfo, CustomMsg, CustomQuery, Empty, GrpcQuery,
8    Querier, Storage,
9};
10use serde::de::DeserializeOwned;
11
12/// Interface of handlers for processing `Stargate`/`Any` message variants
13/// and `Stargate`/`Grpc` queries.
14pub trait Stargate {
15    /// Processes `CosmosMsg::Stargate` message variant.
16    fn execute_stargate<ExecC, QueryC>(
17        &self,
18        _api: &dyn Api,
19        _storage: &mut dyn Storage,
20        _router: &dyn CosmosRouter<ExecC = ExecC, QueryC = QueryC>,
21        _block: &BlockInfo,
22        sender: Addr,
23        type_url: String,
24        value: Binary,
25    ) -> AnyResult<AppResponse>
26    where
27        ExecC: CustomMsg + DeserializeOwned + 'static,
28        QueryC: CustomQuery + DeserializeOwned + 'static,
29    {
30        bail!(
31            "Unexpected stargate execute: type_url={}, value={} from {}",
32            type_url,
33            value,
34            sender,
35        )
36    }
37
38    /// Processes `QueryRequest::Stargate` query.
39    fn query_stargate(
40        &self,
41        _api: &dyn Api,
42        _storage: &dyn Storage,
43        _querier: &dyn Querier,
44        _block: &BlockInfo,
45        path: String,
46        data: Binary,
47    ) -> AnyResult<Binary> {
48        bail!("Unexpected stargate query: path={}, data={}", path, data)
49    }
50
51    /// Processes `CosmosMsg::Any` message variant.
52    fn execute_any<ExecC, QueryC>(
53        &self,
54        _api: &dyn Api,
55        _storage: &mut dyn Storage,
56        _router: &dyn CosmosRouter<ExecC = ExecC, QueryC = QueryC>,
57        _block: &BlockInfo,
58        sender: Addr,
59        msg: AnyMsg,
60    ) -> AnyResult<AppResponse>
61    where
62        ExecC: CustomMsg + DeserializeOwned + 'static,
63        QueryC: CustomQuery + DeserializeOwned + 'static,
64    {
65        bail!("Unexpected any execute: msg={:?} from {}", msg, sender)
66    }
67
68    /// Processes `QueryRequest::Grpc` query.
69    fn query_grpc(
70        &self,
71        _api: &dyn Api,
72        _storage: &dyn Storage,
73        _querier: &dyn Querier,
74        _block: &BlockInfo,
75        request: GrpcQuery,
76    ) -> AnyResult<Binary> {
77        bail!("Unexpected grpc query: request={:?}", request)
78    }
79}
80
81/// Always failing handler for `Stargate`/`Any` message variants and `Stargate`/`Grpc` queries.
82pub struct StargateFailing;
83
84impl Stargate for StargateFailing {}
85
86/// Always accepting handler for `Stargate`/`Any` message variants and `Stargate`/`Grpc` queries.
87pub struct StargateAccepting;
88
89impl Stargate for StargateAccepting {
90    fn execute_stargate<ExecC, QueryC>(
91        &self,
92        _api: &dyn Api,
93        _storage: &mut dyn Storage,
94        _router: &dyn CosmosRouter<ExecC = ExecC, QueryC = QueryC>,
95        _block: &BlockInfo,
96        _sender: Addr,
97        _type_url: String,
98        _value: Binary,
99    ) -> AnyResult<AppResponse>
100    where
101        ExecC: CustomMsg + DeserializeOwned + 'static,
102        QueryC: CustomQuery + DeserializeOwned + 'static,
103    {
104        Ok(AppResponse::default())
105    }
106
107    fn query_stargate(
108        &self,
109        _api: &dyn Api,
110        _storage: &dyn Storage,
111        _querier: &dyn Querier,
112        _block: &BlockInfo,
113        _path: String,
114        _data: Binary,
115    ) -> AnyResult<Binary> {
116        to_json_binary(&Empty {}).map_err(Into::into)
117    }
118
119    fn execute_any<ExecC, QueryC>(
120        &self,
121        _api: &dyn Api,
122        _storage: &mut dyn Storage,
123        _router: &dyn CosmosRouter<ExecC = ExecC, QueryC = QueryC>,
124        _block: &BlockInfo,
125        _sender: Addr,
126        _msg: AnyMsg,
127    ) -> AnyResult<AppResponse>
128    where
129        ExecC: CustomMsg + DeserializeOwned + 'static,
130        QueryC: CustomQuery + DeserializeOwned + 'static,
131    {
132        Ok(AppResponse::default())
133    }
134
135    fn query_grpc(
136        &self,
137        _api: &dyn Api,
138        _storage: &dyn Storage,
139        _querier: &dyn Querier,
140        _block: &BlockInfo,
141        _request: GrpcQuery,
142    ) -> AnyResult<Binary> {
143        Ok(Binary::default())
144    }
145}